@perstack/core 0.0.32 → 0.0.34

package/dist/src/index.js

@@ -136,16 +136,6 @@ function createCompleteRunEvent(jobId, runId, expertKey, checkpoint, output, sta
     usage: createEmptyUsage()
   };
 }
-function createStreamingTextEvent(jobId, runId, text) {
-  return {
-    type: "streamingText",
-    id: createId(),
-    timestamp: Date.now(),
-    jobId,
-    runId,
-    text
-  };
-}
 function createCallToolsEvent(jobId, runId, expertKey, stepNumber, toolCalls, _checkpoint) {
   const expertMessage = {
     id: createId(),
@@ -506,7 +496,216 @@ var messagePartSchema = z.discriminatedUnion("type", [
   thinkingPartSchema
 ]);
 
-// src/schemas/message.ts
+// src/schemas/activity.ts
+var baseActivitySchema = z.object({
+  id: z.string(),
+  expertKey: z.string(),
+  runId: z.string(),
+  previousActivityId: z.string().optional(),
+  delegatedBy: z.object({
+    expertKey: z.string(),
+    runId: z.string()
+  }).optional(),
+  reasoning: z.string().optional()
+});
+var queryActivitySchema = baseActivitySchema.extend({
+  type: z.literal("query"),
+  text: z.string()
+});
+var retryActivitySchema = baseActivitySchema.extend({
+  type: z.literal("retry"),
+  error: z.string(),
+  message: z.string()
+});
+var completeActivitySchema = baseActivitySchema.extend({
+  type: z.literal("complete"),
+  text: z.string()
+});
+var errorActivitySchema = baseActivitySchema.extend({
+  type: z.literal("error"),
+  error: z.string().optional(),
+  errorName: z.string().optional(),
+  isRetryable: z.boolean().optional()
+});
+var attemptCompletionActivitySchema = baseActivitySchema.extend({
+  type: z.literal("attemptCompletion"),
+  remainingTodos: z.array(z.object({ id: z.number(), title: z.string(), completed: z.boolean() })).optional(),
+  error: z.string().optional()
+});
+var todoActivitySchema = baseActivitySchema.extend({
+  type: z.literal("todo"),
+  newTodos: z.array(z.string()).optional(),
+  completedTodos: z.array(z.number()).optional(),
+  todos: z.array(z.object({ id: z.number(), title: z.string(), completed: z.boolean() })),
+  error: z.string().optional()
+});
+var clearTodoActivitySchema = baseActivitySchema.extend({
+  type: z.literal("clearTodo"),
+  error: z.string().optional()
+});
+var readImageFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("readImageFile"),
+  path: z.string(),
+  mimeType: z.string().optional(),
+  size: z.number().optional(),
+  error: z.string().optional()
+});
+var readPdfFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("readPdfFile"),
+  path: z.string(),
+  mimeType: z.string().optional(),
+  size: z.number().optional(),
+  error: z.string().optional()
+});
+var readTextFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("readTextFile"),
+  path: z.string(),
+  content: z.string().optional(),
+  from: z.number().optional(),
+  to: z.number().optional(),
+  error: z.string().optional()
+});
+var editTextFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("editTextFile"),
+  path: z.string(),
+  newText: z.string(),
+  oldText: z.string(),
+  error: z.string().optional()
+});
+var appendTextFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("appendTextFile"),
+  path: z.string(),
+  text: z.string(),
+  error: z.string().optional()
+});
+var writeTextFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("writeTextFile"),
+  path: z.string(),
+  text: z.string(),
+  error: z.string().optional()
+});
+var deleteFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("deleteFile"),
+  path: z.string(),
+  error: z.string().optional()
+});
+var deleteDirectoryActivitySchema = baseActivitySchema.extend({
+  type: z.literal("deleteDirectory"),
+  path: z.string(),
+  recursive: z.boolean().optional(),
+  error: z.string().optional()
+});
+var moveFileActivitySchema = baseActivitySchema.extend({
+  type: z.literal("moveFile"),
+  source: z.string(),
+  destination: z.string(),
+  error: z.string().optional()
+});
+var getFileInfoActivitySchema = baseActivitySchema.extend({
+  type: z.literal("getFileInfo"),
+  path: z.string(),
+  info: z.object({
+    exists: z.boolean(),
+    name: z.string(),
+    directory: z.string(),
+    extension: z.string().nullable(),
+    type: z.enum(["file", "directory"]),
+    mimeType: z.string().nullable(),
+    size: z.number(),
+    sizeFormatted: z.string(),
+    created: z.string(),
+    modified: z.string(),
+    accessed: z.string()
+  }).optional(),
+  error: z.string().optional()
+});
+var createDirectoryActivitySchema = baseActivitySchema.extend({
+  type: z.literal("createDirectory"),
+  path: z.string(),
+  error: z.string().optional()
+});
+var listDirectoryActivitySchema = baseActivitySchema.extend({
+  type: z.literal("listDirectory"),
+  path: z.string(),
+  items: z.array(
+    z.object({
+      name: z.string(),
+      path: z.string(),
+      type: z.enum(["file", "directory"]),
+      size: z.number(),
+      modified: z.string()
+    })
+  ).optional(),
+  error: z.string().optional()
+});
+var execActivitySchema = baseActivitySchema.extend({
+  type: z.literal("exec"),
+  command: z.string(),
+  args: z.array(z.string()),
+  cwd: z.string(),
+  output: z.string().optional(),
+  error: z.string().optional(),
+  stdout: z.string().optional(),
+  stderr: z.string().optional()
+});
+var delegateActivitySchema = baseActivitySchema.extend({
+  type: z.literal("delegate"),
+  delegateExpertKey: z.string(),
+  query: z.string()
+});
+var delegationCompleteActivitySchema = baseActivitySchema.extend({
+  type: z.literal("delegationComplete"),
+  count: z.number()
+});
+var interactiveToolActivitySchema = baseActivitySchema.extend({
+  type: z.literal("interactiveTool"),
+  skillName: z.string(),
+  toolName: z.string(),
+  args: z.record(z.string(), z.unknown())
+});
+var generalToolActivitySchema = baseActivitySchema.extend({
+  type: z.literal("generalTool"),
+  skillName: z.string(),
+  toolName: z.string(),
+  args: z.record(z.string(), z.unknown()),
+  result: z.array(messagePartSchema).optional(),
+  error: z.string().optional()
+});
+var activitySchema = z.discriminatedUnion("type", [
+  queryActivitySchema,
+  retryActivitySchema,
+  completeActivitySchema,
+  errorActivitySchema,
+  attemptCompletionActivitySchema,
+  todoActivitySchema,
+  clearTodoActivitySchema,
+  readImageFileActivitySchema,
+  readPdfFileActivitySchema,
+  readTextFileActivitySchema,
+  editTextFileActivitySchema,
+  appendTextFileActivitySchema,
+  writeTextFileActivitySchema,
+  deleteFileActivitySchema,
+  deleteDirectoryActivitySchema,
+  moveFileActivitySchema,
+  getFileInfoActivitySchema,
+  createDirectoryActivitySchema,
+  listDirectoryActivitySchema,
+  execActivitySchema,
+  delegateActivitySchema,
+  delegationCompleteActivitySchema,
+  interactiveToolActivitySchema,
+  generalToolActivitySchema
+]);
+var parallelActivitiesGroupSchema = z.object({
+  type: z.literal("parallelGroup"),
+  id: z.string(),
+  expertKey: z.string(),
+  runId: z.string(),
+  reasoning: z.string().optional(),
+  activities: z.array(activitySchema)
+});
+var activityOrGroupSchema = z.union([activitySchema, parallelActivitiesGroupSchema]);
 var baseMessageSchema = z.object({
   id: z.string()
 });
@@ -608,7 +807,8 @@ var checkpointSchema = z.object({
     }),
     toolCallId: z.string(),
     toolName: z.string(),
-    checkpointId: z.string()
+    checkpointId: z.string(),
+    runId: z.string()
   }).optional(),
   usage: usageSchema,
   contextWindow: z.number().optional(),
@@ -1166,7 +1366,12 @@ var commandOptionsSchema = z.object({
   resumeFrom: z.string().optional(),
   interactiveToolCallResult: z.boolean().optional(),
   runtime: runtimeNameSchema.optional(),
-  workspace: z.string().optional()
+  workspace: z.string().optional(),
+  volume: z.array(z.string()).optional().transform((value) => value && value.length > 0 ? value : void 0),
+  filter: z.string().optional().transform((value) => {
+    if (value === void 0) return void 0;
+    return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  }).pipe(z.array(z.string()).optional())
 });
 var runCommandInputSchema = z.object({
   expertKey: z.string(),
@@ -1274,17 +1479,30 @@ function createEvent(type) {
     };
   };
 }
+function createStreamingEvent(type, setting, checkpoint, data) {
+  return {
+    type,
+    id: createId(),
+    expertKey: checkpoint.expert.key,
+    timestamp: Date.now(),
+    jobId: setting.jobId,
+    runId: setting.runId,
+    stepNumber: checkpoint.stepNumber,
+    ...data
+  };
+}
 var startRun = createEvent("startRun");
+var resumeFromStop = createEvent("resumeFromStop");
+var proceedToInteractiveTools = createEvent("proceedToInteractiveTools");
 var startGeneration = createEvent("startGeneration");
 var retry = createEvent("retry");
 var callTools = createEvent("callTools");
-var callInteractiveTool = createEvent("callInteractiveTool");
-var callDelegate = createEvent("callDelegate");
+var finishMcpTools = createEvent("finishMcpTools");
+var skipDelegates = createEvent("skipDelegates");
 var resolveToolResults = createEvent("resolveToolResults");
 var attemptCompletion = createEvent("attemptCompletion");
 var finishToolCall = createEvent("finishToolCall");
 var resumeToolCalls = createEvent("resumeToolCalls");
-var finishAllToolCalls = createEvent("finishAllToolCalls");
 var completeRun = createEvent("completeRun");
 var stopRunByInteractiveTool = createEvent("stopRunByInteractiveTool");
 var stopRunByDelegate = createEvent("stopRunByDelegate");
@@ -1301,6 +1519,50 @@ function createRuntimeEvent(type, jobId, runId, data) {
     ...data
   };
 }
+var EXPERT_STATE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "startRun",
+  "resumeFromStop",
+  "proceedToInteractiveTools",
+  "startGeneration",
+  "retry",
+  "callTools",
+  "finishMcpTools",
+  "skipDelegates",
+  "resolveToolResults",
+  "attemptCompletion",
+  "finishToolCall",
+  "resumeToolCalls",
+  "continueToNextStep",
+  "stopRunByInteractiveTool",
+  "stopRunByDelegate",
+  "stopRunByExceededMaxSteps",
+  "stopRunByError",
+  "completeRun"
+]);
+var STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "startStreamingReasoning",
+  "streamReasoning",
+  "completeStreamingReasoning",
+  "startStreamingRunResult",
+  "streamRunResult",
+  "completeStreamingRunResult"
+]);
+var RUNTIME_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "initializeRuntime",
+  "skillStarting",
+  "skillConnected",
+  "skillStderr",
+  "skillDisconnected",
+  "dockerBuildProgress",
+  "dockerContainerStatus",
+  "proxyAccess"
+]);
+function isValidEventType(type) {
+  return EXPERT_STATE_EVENT_TYPES.has(type) || STREAMING_EVENT_TYPES.has(type);
+}
+function isValidRuntimeEventType(type) {
+  return RUNTIME_EVENT_TYPES.has(type);
+}
 var stepSchema = z.object({
   stepNumber: z.number(),
   inputMessages: z.array(z.union([instructionMessageSchema, userMessageSchema, toolMessageSchema])).optional(),
@@ -1314,6 +1576,440 @@ var stepSchema = z.object({
   finishedAt: z.number().optional()
 });
 
+// src/utils/activity.ts
+var BASE_SKILL_PREFIX = "@perstack/base";
+function extractReasoning(newMessages) {
+  const thinkingParts = [];
+  for (const message of newMessages) {
+    for (const content of message.contents) {
+      if (content.type === "thinkingPart") {
+        thinkingParts.push(content);
+      }
+    }
+  }
+  if (thinkingParts.length === 0) return void 0;
+  return thinkingParts.map((p) => p.thinking).join("\n\n");
+}
+function wrapInGroupIfParallel(activities, reasoning, expertKey, runId, stepNumber) {
+  if (activities.length <= 1) {
+    return activities;
+  }
+  const activitiesWithoutReasoning = activities.map((a) => {
+    const { reasoning: _, ...rest } = a;
+    return rest;
+  });
+  const group = {
+    type: "parallelGroup",
+    id: `parallel-${runId}-step${stepNumber}`,
+    expertKey,
+    runId,
+    reasoning,
+    activities: activitiesWithoutReasoning
+  };
+  return [group];
+}
+function getActivities(params) {
+  const { checkpoint, step } = params;
+  const { status, delegateTo, runId, stepNumber } = checkpoint;
+  const expertKey = checkpoint.expert.key;
+  const reasoning = extractReasoning(step.newMessages);
+  if (status === "completed") {
+    return [createCompleteActivity(step.newMessages, reasoning)];
+  }
+  if (status === "stoppedByError") {
+    return [createErrorActivity(checkpoint, reasoning)];
+  }
+  if (status === "stoppedByDelegate") {
+    if (!delegateTo || delegateTo.length === 0) {
+      return [
+        createRetryActivity(
+          step.newMessages,
+          reasoning,
+          "Delegate status but no delegation targets"
+        )
+      ];
+    }
+    const activities2 = delegateTo.map((d) => createDelegateActivity(d, reasoning));
+    return wrapInGroupIfParallel(activities2, reasoning, expertKey, runId, stepNumber);
+  }
+  if (status === "stoppedByInteractiveTool") {
+    const toolCalls2 = step.toolCalls ?? [];
+    if (toolCalls2.length === 0) {
+      return [createRetryActivity(step.newMessages, reasoning)];
+    }
+    const activities2 = toolCalls2.map(
+      (tc) => createInteractiveToolActivity(tc.skillName, tc.toolName, tc, reasoning)
+    );
+    return wrapInGroupIfParallel(activities2, reasoning, expertKey, runId, stepNumber);
+  }
+  const toolCalls = step.toolCalls ?? [];
+  const toolResults = step.toolResults ?? [];
+  if (toolCalls.length === 0) {
+    return [createRetryActivity(step.newMessages, reasoning)];
+  }
+  const activities = [];
+  for (const toolCall of toolCalls) {
+    const toolResult = toolResults.find((tr) => tr.id === toolCall.id);
+    if (!toolResult) {
+      continue;
+    }
+    const { skillName, toolName } = toolCall;
+    if (skillName.startsWith(BASE_SKILL_PREFIX)) {
+      activities.push(createBaseToolActivity(toolName, toolCall, toolResult, reasoning));
+    } else {
+      activities.push(
+        createGeneralToolActivity(skillName, toolName, toolCall, toolResult, reasoning)
+      );
+    }
+  }
+  if (activities.length === 0) {
+    return [createRetryActivity(step.newMessages, reasoning)];
+  }
+  return wrapInGroupIfParallel(activities, reasoning, expertKey, runId, stepNumber);
+}
+function createCompleteActivity(newMessages, reasoning) {
+  const lastExpertMessage = [...newMessages].reverse().find((m) => m.type === "expertMessage");
+  const textPart = lastExpertMessage?.contents.find((c) => c.type === "textPart");
+  return {
+    type: "complete",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    text: textPart?.text ?? ""
+  };
+}
+function createDelegateActivity(delegate, reasoning) {
+  return {
+    type: "delegate",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    delegateExpertKey: delegate.expert.key,
+    query: delegate.query
+  };
+}
+function createInteractiveToolActivity(skillName, toolName, toolCall, reasoning) {
+  return {
+    type: "interactiveTool",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    skillName,
+    toolName,
+    args: toolCall.args
+  };
+}
+function createRetryActivity(newMessages, reasoning, customError) {
+  const lastMessage = newMessages[newMessages.length - 1];
+  const textPart = lastMessage?.contents.find((c) => c.type === "textPart");
+  return {
+    type: "retry",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    error: customError ?? "No tool call or result found",
+    message: textPart?.text ?? ""
+  };
+}
+function createErrorActivity(checkpoint, reasoning) {
+  const error = checkpoint.error;
+  return {
+    type: "error",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    error: error?.message ?? "Unknown error",
+    errorName: error?.name,
+    isRetryable: error?.isRetryable
+  };
+}
+function createBaseToolActivity(toolName, toolCall, toolResult, reasoning) {
+  const args = toolCall.args;
+  const resultContents = toolResult.result;
+  const errorText = getErrorFromResult(resultContents);
+  const baseFields = { id: "", expertKey: "", runId: "", reasoning };
+  switch (toolName) {
+    case "attemptCompletion": {
+      const remainingTodos = parseRemainingTodosFromResult(resultContents);
+      return {
+        type: "attemptCompletion",
+        ...baseFields,
+        remainingTodos,
+        error: errorText
+      };
+    }
+    case "todo": {
+      const todos = parseTodosFromResult(resultContents);
+      return {
+        type: "todo",
+        ...baseFields,
+        newTodos: Array.isArray(args["newTodos"]) ? args["newTodos"].map(String) : void 0,
+        completedTodos: Array.isArray(args["completedTodos"]) ? args["completedTodos"].map(Number) : void 0,
+        todos,
+        error: errorText
+      };
+    }
+    case "clearTodo":
+      return {
+        type: "clearTodo",
+        ...baseFields,
+        error: errorText
+      };
+    case "readImageFile":
+      return {
+        type: "readImageFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        mimeType: parseStringField(resultContents, "mimeType"),
+        size: parseNumberField(resultContents, "size"),
+        error: errorText
+      };
+    case "readPdfFile":
+      return {
+        type: "readPdfFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        mimeType: parseStringField(resultContents, "mimeType"),
+        size: parseNumberField(resultContents, "size"),
+        error: errorText
+      };
+    case "readTextFile":
+      return {
+        type: "readTextFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        content: parseStringField(resultContents, "content"),
+        from: typeof args["from"] === "number" ? args["from"] : void 0,
+        to: typeof args["to"] === "number" ? args["to"] : void 0,
+        error: errorText
+      };
+    case "editTextFile":
+      return {
+        type: "editTextFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        newText: String(args["newText"] ?? ""),
+        oldText: String(args["oldText"] ?? ""),
+        error: errorText
+      };
+    case "appendTextFile":
+      return {
+        type: "appendTextFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        text: String(args["text"] ?? ""),
+        error: errorText
+      };
+    case "writeTextFile":
+      return {
+        type: "writeTextFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        text: String(args["text"] ?? ""),
+        error: errorText
+      };
+    case "deleteFile":
+      return {
+        type: "deleteFile",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        error: errorText
+      };
+    case "deleteDirectory":
+      return {
+        type: "deleteDirectory",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        recursive: typeof args["recursive"] === "boolean" ? args["recursive"] : void 0,
+        error: errorText
+      };
+    case "moveFile":
+      return {
+        type: "moveFile",
+        ...baseFields,
+        source: String(args["source"] ?? ""),
+        destination: String(args["destination"] ?? ""),
+        error: errorText
+      };
+    case "getFileInfo":
+      return {
+        type: "getFileInfo",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        info: parseFileInfoFromResult(resultContents),
+        error: errorText
+      };
+    case "createDirectory":
+      return {
+        type: "createDirectory",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        error: errorText
+      };
+    case "listDirectory":
+      return {
+        type: "listDirectory",
+        ...baseFields,
+        path: String(args["path"] ?? ""),
+        items: parseListDirectoryFromResult(resultContents),
+        error: errorText
+      };
+    case "exec":
+      return {
+        type: "exec",
+        ...baseFields,
+        command: String(args["command"] ?? ""),
+        args: Array.isArray(args["args"]) ? args["args"].map(String) : [],
+        cwd: String(args["cwd"] ?? ""),
+        output: parseStringField(resultContents, "output"),
+        error: errorText,
+        stdout: parseStringField(resultContents, "stdout"),
+        stderr: parseStringField(resultContents, "stderr")
+      };
+    default:
+      return createGeneralToolActivity(
+        toolCall.skillName,
+        toolName,
+        toolCall,
+        toolResult,
+        reasoning
+      );
+  }
+}
+function createGeneralToolActivity(skillName, toolName, toolCall, toolResult, reasoning) {
+  const errorText = getErrorFromResult(toolResult.result);
+  return {
+    type: "generalTool",
+    id: "",
+    expertKey: "",
+    runId: "",
+    reasoning,
+    skillName,
+    toolName,
+    args: toolCall.args,
+    result: toolResult.result,
+    error: errorText
+  };
+}
+function getErrorFromResult(result) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    if (typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    const trimmed = textPart.text.trim();
+    if (trimmed.toLowerCase().startsWith("error:") || trimmed.toLowerCase().startsWith("error ")) {
+      return textPart.text;
+    }
+  }
+  return void 0;
+}
+function parseStringField(result, field) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    return typeof parsed[field] === "string" ? parsed[field] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseNumberField(result, field) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    return typeof parsed[field] === "number" ? parsed[field] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseRemainingTodosFromResult(result) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    if (Array.isArray(parsed.remainingTodos)) {
+      return parsed.remainingTodos.map(
+        (t, i) => ({
+          id: typeof t.id === "number" ? t.id : i,
+          title: typeof t.title === "string" ? t.title : "",
+          completed: typeof t.completed === "boolean" ? t.completed : false
+        })
+      );
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseTodosFromResult(result) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return [];
+  try {
+    const parsed = JSON.parse(textPart.text);
+    if (Array.isArray(parsed.todos)) {
+      return parsed.todos.map(
+        (t, i) => ({
+          id: typeof t.id === "number" ? t.id : i,
+          title: typeof t.title === "string" ? t.title : "",
+          completed: typeof t.completed === "boolean" ? t.completed : false
+        })
+      );
+    }
+  } catch {
+  }
+  return [];
+}
+function parseFileInfoFromResult(result) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    return {
+      exists: typeof parsed.exists === "boolean" ? parsed.exists : true,
+      name: String(parsed.name ?? ""),
+      directory: String(parsed.directory ?? ""),
+      extension: typeof parsed.extension === "string" ? parsed.extension : null,
+      type: parsed.type === "directory" ? "directory" : "file",
+      mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : null,
+      size: typeof parsed.size === "number" ? parsed.size : 0,
+      sizeFormatted: String(parsed.sizeFormatted ?? ""),
+      created: String(parsed.created ?? ""),
+      modified: String(parsed.modified ?? ""),
+      accessed: String(parsed.accessed ?? "")
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parseListDirectoryFromResult(result) {
+  const textPart = result.find((p) => p.type === "textPart");
+  if (!textPart?.text) return void 0;
+  try {
+    const parsed = JSON.parse(textPart.text);
+    if (!Array.isArray(parsed.items)) return void 0;
+    return parsed.items.map(
+      (item) => ({
+        name: String(item.name ?? ""),
+        path: String(item.path ?? ""),
+        type: item.type === "directory" ? "directory" : "file",
+        size: typeof item.size === "number" ? item.size : 0,
+        modified: String(item.modified ?? "")
+      })
+    );
+  } catch {
+    return void 0;
+  }
+}
+
 // src/utils/env-filter.ts
 var SAFE_ENV_VARS = [
   // System
@@ -1364,6 +2060,24 @@ function getFilteredEnv(additional) {
   return filtered;
 }
 
+// src/utils/event-filter.ts
+function validateEventFilter(filter) {
+  const invalid = filter.filter((type) => !isValidEventType(type) && !isValidRuntimeEventType(type));
+  if (invalid.length > 0) {
+    throw new Error(
+      `Invalid event type(s): ${invalid.join(", ")}. Valid event types are: startRun, completeRun, stopRunByError, callTools, etc. See documentation for full list.`
+    );
+  }
+  return filter;
+}
+function createFilteredEventListener(listener, allowedTypes) {
+  return (event) => {
+    if (allowedTypes.has(event.type)) {
+      listener(event);
+    }
+  };
+}
+
 // src/utils/zod-error.ts
 function formatZodError(error) {
   const issues = error.issues.map((issue) => {
@@ -1382,6 +2096,6 @@ function parseWithFriendlyError(schema, data, context) {
   throw new Error(`${prefix}${formatZodError(result.error)}`);
 }
 
-export { BaseAdapter, SAFE_ENV_VARS, amazonBedrockProviderConfigSchema, anthropicProviderConfigSchema, anthropicProviderSkillSchema, anthropicProviderToolNameSchema, attemptCompletion, azureOpenAIProviderToolNameSchema, azureOpenAiProviderConfigSchema, basePartSchema, builtinAnthropicSkillSchema, callDelegate, callInteractiveTool, callTools, checkpointSchema, checkpointStatusSchema, completeRun, continueToNextStep, createCallToolsEvent, createCompleteRunEvent, createEmptyUsage, createEvent, createNormalizedCheckpoint, createResolveToolResultsEvent, createRuntimeEvent, createRuntimeInitEvent, createStartRunEvent, createStreamingTextEvent, createToolMessage, customAnthropicSkillSchema, deepseekProviderConfigSchema, defaultMaxRetries, defaultMaxSteps, defaultPerstackApiBaseUrl, defaultReasoningBudget, defaultTimeout, delegationTargetSchema, domainPatternSchema, envNameRegex, expertKeyRegex, expertMessageSchema, expertNameRegex, expertSchema, expertVersionRegex, fileBinaryPartSchema, fileInlinePartSchema, fileSearchOptionsSchema, fileUrlPartSchema, finishAllToolCalls, finishToolCall, formatZodError, getAdapter, getFilteredEnv, getRegisteredRuntimes, googleGenerativeAiProviderConfigSchema, googleProviderToolNameSchema, googleVertexProviderConfigSchema, hasCustomProviderSkills, headersSchema, imageBinaryPartSchema, imageInlinePartSchema, imageUrlPartSchema, instructionMessageSchema, interactiveSkillSchema, interactiveToolSchema, isAdapterAvailable, jobSchema, jobStatusSchema, knownModels, lockfileExpertSchema, lockfileSchema, lockfileToolDefinitionSchema, maxApplicationNameLength, maxCheckpointToolCallIdLength, maxEnvNameLength, maxExpertDelegateItems, maxExpertDescriptionLength, maxExpertInstructionLength, maxExpertJobFileNameLength, maxExpertJobQueryLength, maxExpertKeyLength, maxExpertNameLength, maxExpertSkillItems, maxExpertTagItems, maxExpertVersionTagLength, maxOrganizationNameLength, maxSkillDescriptionLength, maxSkillEndpointLength, maxSkillInputJsonSchemaLength, maxSkillNameLength, maxSkillPickOmitItems, maxSkillRequiredEnvItems, maxSkillRuleLength, maxSkillToolItems, maxSkillToolNameLength, mcpSseSkillSchema, mcpStdioSkillSchema, messagePartSchema, messageSchema, ollamaProviderConfigSchema, openAiProviderConfigSchema, openaiProviderToolNameSchema, organizationNameRegex, packageWithVersionRegex, parseExpertKey, parseWithFriendlyError, perstackConfigSchema, providerConfigSchema, providerNameSchema, providerTableSchema, providerToolOptionsSchema, reasoningBudgetSchema, registerAdapter, resolveToolResults, resumeToolCalls, retry, runCommandInputSchema, runParamsSchema, runSettingSchema, runtimeNameSchema, skillSchema, startCommandInputSchema, startGeneration, startRun, stepSchema, stopRunByDelegate, stopRunByError, stopRunByExceededMaxSteps, stopRunByInteractiveTool, tagNameRegex, textPartSchema, thinkingPartSchema, toolCallPartSchema, toolCallSchema, toolMessageSchema, toolResultPartSchema, toolResultSchema, urlSafeRegex, usageSchema, userMessageSchema, vertexProviderToolNameSchema, webFetchOptionsSchema, webSearchOptionsSchema };
+export { BASE_SKILL_PREFIX, BaseAdapter, SAFE_ENV_VARS, activityOrGroupSchema, activitySchema, amazonBedrockProviderConfigSchema, anthropicProviderConfigSchema, anthropicProviderSkillSchema, anthropicProviderToolNameSchema, appendTextFileActivitySchema, attemptCompletion, attemptCompletionActivitySchema, azureOpenAIProviderToolNameSchema, azureOpenAiProviderConfigSchema, basePartSchema, builtinAnthropicSkillSchema, callTools, checkpointSchema, checkpointStatusSchema, clearTodoActivitySchema, completeActivitySchema, completeRun, continueToNextStep, createBaseToolActivity, createCallToolsEvent, createCompleteRunEvent, createDirectoryActivitySchema, createEmptyUsage, createEvent, createFilteredEventListener, createGeneralToolActivity, createNormalizedCheckpoint, createResolveToolResultsEvent, createRuntimeEvent, createRuntimeInitEvent, createStartRunEvent, createStreamingEvent, createToolMessage, customAnthropicSkillSchema, deepseekProviderConfigSchema, defaultMaxRetries, defaultMaxSteps, defaultPerstackApiBaseUrl, defaultReasoningBudget, defaultTimeout, delegateActivitySchema, delegationCompleteActivitySchema, delegationTargetSchema, deleteDirectoryActivitySchema, deleteFileActivitySchema, domainPatternSchema, editTextFileActivitySchema, envNameRegex, errorActivitySchema, execActivitySchema, expertKeyRegex, expertMessageSchema, expertNameRegex, expertSchema, expertVersionRegex, fileBinaryPartSchema, fileInlinePartSchema, fileSearchOptionsSchema, fileUrlPartSchema, finishMcpTools, finishToolCall, formatZodError, generalToolActivitySchema, getActivities, getAdapter, getFileInfoActivitySchema, getFilteredEnv, getRegisteredRuntimes, googleGenerativeAiProviderConfigSchema, googleProviderToolNameSchema, googleVertexProviderConfigSchema, hasCustomProviderSkills, headersSchema, imageBinaryPartSchema, imageInlinePartSchema, imageUrlPartSchema, instructionMessageSchema, interactiveSkillSchema, interactiveToolActivitySchema, interactiveToolSchema, isAdapterAvailable, isValidEventType, isValidRuntimeEventType, jobSchema, jobStatusSchema, knownModels, listDirectoryActivitySchema, lockfileExpertSchema, lockfileSchema, lockfileToolDefinitionSchema, maxApplicationNameLength, maxCheckpointToolCallIdLength, maxEnvNameLength, maxExpertDelegateItems, maxExpertDescriptionLength, maxExpertInstructionLength, maxExpertJobFileNameLength, maxExpertJobQueryLength, maxExpertKeyLength, maxExpertNameLength, maxExpertSkillItems, maxExpertTagItems, maxExpertVersionTagLength, maxOrganizationNameLength, maxSkillDescriptionLength, maxSkillEndpointLength, maxSkillInputJsonSchemaLength, maxSkillNameLength, maxSkillPickOmitItems, maxSkillRequiredEnvItems, maxSkillRuleLength, maxSkillToolItems, maxSkillToolNameLength, mcpSseSkillSchema, mcpStdioSkillSchema, messagePartSchema, messageSchema, moveFileActivitySchema, ollamaProviderConfigSchema, openAiProviderConfigSchema, openaiProviderToolNameSchema, organizationNameRegex, packageWithVersionRegex, parallelActivitiesGroupSchema, parseExpertKey, parseWithFriendlyError, perstackConfigSchema, proceedToInteractiveTools, providerConfigSchema, providerNameSchema, providerTableSchema, providerToolOptionsSchema, queryActivitySchema, readImageFileActivitySchema, readPdfFileActivitySchema, readTextFileActivitySchema, reasoningBudgetSchema, registerAdapter, resolveToolResults, resumeFromStop, resumeToolCalls, retry, retryActivitySchema, runCommandInputSchema, runParamsSchema, runSettingSchema, runtimeNameSchema, skillSchema, skipDelegates, startCommandInputSchema, startGeneration, startRun, stepSchema, stopRunByDelegate, stopRunByError, stopRunByExceededMaxSteps, stopRunByInteractiveTool, tagNameRegex, textPartSchema, thinkingPartSchema, todoActivitySchema, toolCallPartSchema, toolCallSchema, toolMessageSchema, toolResultPartSchema, toolResultSchema, urlSafeRegex, usageSchema, userMessageSchema, validateEventFilter, vertexProviderToolNameSchema, webFetchOptionsSchema, webSearchOptionsSchema, writeTextFileActivitySchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map