chore: import upstream snapshot with attribution

apps/sim/executor/handlers/pi/context.ts

@@ -0,0 +1,118 @@
+/**
+ * Reuses the Agent block's skills and memory subsystems for Pi runs. Skills
+ * resolve to full `{ name, content }` entries (so a backend can surface them as
+ * Pi skills), and multi-turn memory goes through the shared `memoryService`
+ * keyed by `memoryType`/`conversationId` — seeding the run and persisting the
+ * user task plus the agent's final message.
+ */
+
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { memoryService } from '@/executor/handlers/agent/memory'
+import { resolveSkillContentById } from '@/executor/handlers/agent/skills-resolver'
+import type { AgentInputs, Message, SkillInput } from '@/executor/handlers/agent/types'
+import type { PiMessage, PiSkill } from '@/executor/handlers/pi/backend'
+import type { ExecutionContext } from '@/executor/types'
+
+const logger = createLogger('PiContext')
+
+/** Memory configuration — the Agent block's memory input fields, reused as-is. */
+export type PiMemoryConfig = Pick<
+  AgentInputs,
+  'memoryType' | 'conversationId' | 'slidingWindowSize' | 'slidingWindowTokens' | 'model'
+>
+
+function isMemoryEnabled(config: PiMemoryConfig): boolean {
+  return !!config.memoryType && config.memoryType !== 'none'
+}
+
+/** Resolves selected skill inputs to full `{ name, content }` entries for Pi. */
+export async function resolvePiSkills(
+  skillInputs: unknown,
+  workspaceId: string | undefined
+): Promise<PiSkill[]> {
+  if (!Array.isArray(skillInputs) || !workspaceId) return []
+
+  const skills: PiSkill[] = []
+  for (const input of skillInputs as SkillInput[]) {
+    if (!input?.skillId) continue
+    try {
+      const resolved = await resolveSkillContentById(input.skillId, workspaceId)
+      if (resolved) skills.push({ name: resolved.name, content: resolved.content })
+    } catch (error) {
+      logger.warn('Failed to resolve skill for Pi', {
+        skillId: input.skillId,
+        error: getErrorMessage(error),
+      })
+    }
+  }
+  return skills
+}
+
+/** Loads prior conversation messages to seed the Pi run. */
+export async function loadPiMemory(
+  ctx: ExecutionContext,
+  config: PiMemoryConfig
+): Promise<PiMessage[]> {
+  if (!isMemoryEnabled(config)) return []
+  try {
+    const messages = await memoryService.fetchMemoryMessages(ctx, config)
+    return messages.map((message: Message) => ({ role: message.role, content: message.content }))
+  } catch (error) {
+    logger.warn('Failed to load Pi memory', { error: getErrorMessage(error) })
+    return []
+  }
+}
+
+/**
+ * Builds the prompt: optional operating `guidance` (mode-specific constraints),
+ * then skills, prior memory, and the task.
+ */
+export function buildPiPrompt(input: {
+  skills: PiSkill[]
+  initialMessages: PiMessage[]
+  task: string
+  guidance?: string
+}): string {
+  const parts: string[] = []
+
+  if (input.guidance) {
+    parts.push(`# Operating instructions\n${input.guidance}`)
+  }
+
+  if (input.skills.length > 0) {
+    parts.push('# Available skills')
+    for (const skill of input.skills) {
+      parts.push(`## ${skill.name}\n${skill.content}`)
+    }
+  }
+
+  if (input.initialMessages.length > 0) {
+    parts.push('# Prior conversation')
+    for (const message of input.initialMessages) {
+      parts.push(`${message.role}: ${message.content}`)
+    }
+  }
+
+  parts.push('# Task')
+  parts.push(input.task)
+  return parts.join('\n\n')
+}
+
+/** Persists the user task and the agent's final message to memory. */
+export async function appendPiMemory(
+  ctx: ExecutionContext,
+  config: PiMemoryConfig,
+  task: string,
+  finalText: string
+): Promise<void> {
+  if (!isMemoryEnabled(config)) return
+  try {
+    await memoryService.appendToMemory(ctx, config, { role: 'user', content: task })
+    if (finalText) {
+      await memoryService.appendToMemory(ctx, config, { role: 'assistant', content: finalText })
+    }
+  } catch (error) {
+    logger.warn('Failed to append Pi memory', { error: getErrorMessage(error) })
+  }
+}