openmates 0.17.0-alpha.1 → 0.17.0-alpha.3

package/dist/{chunk-BNHR25YW.js → chunk-TNSNIRLS.js}

@@ -14392,6 +14392,17 @@ var APP_SKILL_METADATA = [
       "required": [
         "prompt"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "answer": {
+          "type": "string"
+        },
+        "conversation": {
+          "type": "string"
+        }
+      }
     }
   },
   {
@@ -14682,6 +14693,23 @@ var APP_SKILL_METADATA = [
       "required": [
         "companies"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "result_count": {
+          "type": "integer"
+        },
+        "provider": {
+          "type": "string"
+        },
+        "results": {
+          "type": "array"
+        }
+      }
     }
   },
   {
@@ -14752,6 +14780,251 @@ var APP_SKILL_METADATA = [
       ]
     }
   },
+  {
+    "app_id": "code",
+    "skill_id": "run",
+    "app_namespace_ts": "code",
+    "skill_method_ts": "run",
+    "app_namespace_py": "code",
+    "skill_method_py": "run",
+    "description_key": "app_skills.code.run.description",
+    "description": "Run a code embed in an isolated E2B sandbox. Use automatically only for code the assistant created or edited in the current turn; ask the user before running unmodified user-supplied code or after the initial run plus two unprompted reruns. The sandbox receives code files from the current chat, installs supported dependency manifests, executes the selected file, streams terminal status, and returns safe artifact metadata. Pricing is 5 credits per started minute of sandbox runtime.",
+    "schema": {
+      "type": "object",
+      "properties": {
+        "requests": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 10,
+          "description": "Array of direct or chat-bound Code Run requests for the custom REST/SDK route.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "mode": {
+                "type": "string",
+                "enum": [
+                  "direct",
+                  "chat_bound"
+                ],
+                "default": "direct",
+                "description": "Direct runs use caller-supplied files and stay transient; chat_bound runs use a chat/embed target and persist encrypted output."
+              },
+              "entry_path": {
+                "type": "string",
+                "description": "Entrypoint file path for direct runs."
+              },
+              "files": {
+                "type": "array",
+                "maxItems": 50,
+                "description": "Direct-run files with base64-encoded content. The backend never fetches local paths or URLs.",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "path": {
+                      "type": "string"
+                    },
+                    "content_base64": {
+                      "type": "string"
+                    },
+                    "language": {
+                      "type": "string"
+                    },
+                    "mime_type": {
+                      "type": "string",
+                      "default": "text/plain"
+                    },
+                    "is_target": {
+                      "type": "boolean",
+                      "default": false
+                    }
+                  },
+                  "required": [
+                    "path",
+                    "content_base64"
+                  ]
+                }
+              },
+              "chat_id": {
+                "type": "string",
+                "description": "Chat ID for chat-bound runs."
+              },
+              "target_embed_id": {
+                "type": "string",
+                "description": "Target code embed ID for chat-bound runs."
+              },
+              "selected_embed_ids": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "description": "Optional related embed IDs to include in chat-bound runs."
+              },
+              "dependency_installs": {
+                "type": "array",
+                "maxItems": 20,
+                "description": "Optional explicit dependency installs.",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "ecosystem": {
+                      "type": "string",
+                      "enum": [
+                        "python",
+                        "npm"
+                      ]
+                    },
+                    "packages": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    }
+                  },
+                  "required": [
+                    "ecosystem",
+                    "packages"
+                  ]
+                }
+              },
+              "enable_internet": {
+                "type": "boolean",
+                "default": true,
+                "description": "Allow outbound internet access from the E2B sandbox."
+              }
+            }
+          }
+        }
+      },
+      "required": [
+        "requests"
+      ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "results": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "execution_id": {
+                "type": "string"
+              },
+              "status": {
+                "type": "string"
+              },
+              "target_filename": {
+                "type": "string"
+              },
+              "files": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "credits_per_minute": {
+                "type": "integer"
+              },
+              "persisted_output": {
+                "type": "boolean"
+              },
+              "stream_path": {
+                "type": "string"
+              },
+              "status_path": {
+                "type": "string"
+              },
+              "final": {
+                "type": "object",
+                "description": "Final status fetched from status_path by SDK helpers. Direct runs remain transient.",
+                "properties": {
+                  "status": {
+                    "type": "string"
+                  },
+                  "exit_code": {
+                    "type": "integer"
+                  },
+                  "output": {
+                    "type": "string"
+                  },
+                  "error": {
+                    "type": "string"
+                  },
+                  "duration_seconds": {
+                    "type": "number"
+                  },
+                  "charged_credits": {
+                    "type": "integer"
+                  },
+                  "charged_minutes": {
+                    "type": "integer"
+                  },
+                  "artifacts": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "path": {
+                          "type": "string"
+                        },
+                        "normalized_path": {
+                          "type": "string"
+                        },
+                        "mime_type": {
+                          "type": "string"
+                        },
+                        "kind": {
+                          "type": "string"
+                        },
+                        "size_bytes": {
+                          "type": "integer"
+                        },
+                        "status": {
+                          "type": "string"
+                        },
+                        "asset_id": {
+                          "type": "string"
+                        },
+                        "file_id": {
+                          "type": "string"
+                        },
+                        "variant": {
+                          "type": "string"
+                        },
+                        "version": {
+                          "type": "integer"
+                        },
+                        "download_url": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  },
+                  "skipped_artifacts": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "path": {
+                          "type": "string"
+                        },
+                        "normalized_path": {
+                          "type": "string"
+                        },
+                        "reason": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   {
     "app_id": "code",
     "skill_id": "image_to_html",
@@ -15190,6 +15463,17 @@ Note: The 'id' field is auto-generated if not provided.
       "required": [
         "requests"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "result_count": {
+          "type": "integer"
+        }
+      }
     }
   },
   {
@@ -16202,6 +16486,17 @@ Note: The 'id' field is auto-generated if not provided - you don't need to inclu
       "required": [
         "requests"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "result_count": {
+          "type": "integer"
+        }
+      }
     }
   },
   {
@@ -17929,6 +18224,20 @@ Note: The 'id' field is auto-generated if not provided - you don't need to inclu
       "required": [
         "location"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "rain_probability": {
+          "type": "number"
+        },
+        "max_temperature_c": {
+          "type": "number"
+        }
+      }
     }
   },
   {
@@ -18120,6 +18429,17 @@ Note: The 'id' field is auto-generated if not provided - you don't need to inclu
       "required": [
         "requests"
       ]
+    },
+    "output_schema": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "result_count": {
+          "type": "integer"
+        }
+      }
     }
   },
   {
@@ -18363,6 +18683,14 @@ var CodeAppSkills = class {
   async removeSecrets(input, options) {
     return this.runSkill("code", "remove_secrets", input, options);
   }
+  /**
+   * Run a code embed in an isolated E2B sandbox. Use automatically only for code the assistant created or edited in the current turn; ask the user before running unmodified user-supplied code or after the initial run plus two unprompted reruns. The sandbox receives code files from the current chat, installs supported dependency manifests, executes the selected file, streams terminal status, and returns safe artifact metadata. Pricing is 5 credits per started minute of sandbox runtime.
+   * Description key: app_skills.code.run.description
+   * Skill: code/run
+   */
+  async run(input, options) {
+    return this.runSkill("code", "run", input, options);
+  }
   /**
    * Search GitHub repositories. Use this instead of web.search whenever the user asks to find GitHub repos, repositories, open-source libraries, starred repos, or repo examples by topic, language, framework, or project need. Returns licensed repository embeds. Costs 10 credits per search.
    * Description key: code.search_repos.description
@@ -19383,6 +19711,9 @@ var DEFAULT_RECOVERY_TIMEOUT_MS = 6e4;
 var SKILL_TASK_POLL_INTERVAL_MS2 = 2e3;
 var SKILL_TASK_POLL_TIMEOUT_MS2 = 12e5;
 var SKILL_TASK_POLL_TRANSIENT_ERROR_STATUS2 = 500;
+var CODE_RUN_POLL_INTERVAL_MS = 1e3;
+var CODE_RUN_POLL_TIMEOUT_MS = 12e5;
+var CODE_RUN_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["finished", "failed", "timeout", "cancelled"]);
 var PROMPT_INJECTION_DISABLED2 = "disabled";
 var CANONICAL_UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function withAppSkillRunOptions(input, options) {
@@ -19498,6 +19829,9 @@ var OpenMates = class {
   }
   async runAppSkill(appId, skillId, input, options) {
     const response = await this.request(`/v1/apps/${appId}/skills/${skillId}`, withAppSkillRunOptions(input, options));
+    if (appId === "code" && skillId === "run") {
+      return this.resolveCodeRunSkillResponse(response);
+    }
     return this.resolveAsyncSkillResponse(response);
   }
   async runConnectedAccountSkill(appId, skillId, input, options = {}) {
@@ -19766,6 +20100,65 @@ var OpenMates = class {
     }
     return responseData;
   }
+  async resolveCodeRunSkillResponse(responseData) {
+    const envelope = responseData;
+    const data = envelope?.data ?? envelope;
+    const results = Array.isArray(data?.results) ? data.results : [];
+    if (results.length === 0) return responseData;
+    const resolvedResults = await Promise.all(results.map(async (result) => {
+      if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+      const item = result;
+      const statusPath = typeof item.status_path === "string" ? item.status_path : null;
+      if (!statusPath) return item;
+      return { ...item, final: await this.pollCodeRunUntilComplete(statusPath) };
+    }));
+    const resolvedData = { ...data, results: resolvedResults };
+    if (envelope && typeof envelope === "object" && "success" in envelope) {
+      return { ...envelope, data: resolvedData };
+    }
+    return resolvedData;
+  }
+  async pollCodeRunUntilComplete(statusPath) {
+    const path2 = this.normalizeCodeRunStatusPath(statusPath);
+    const started = Date.now();
+    let lastTransientError = null;
+    while (Date.now() - started < CODE_RUN_POLL_TIMEOUT_MS) {
+      let response;
+      try {
+        response = await fetch(`${this.apiUrl}${path2}`, {
+          method: "GET",
+          headers: this.headers(false)
+        });
+      } catch (error) {
+        lastTransientError = error instanceof Error ? error.message : String(error);
+        await new Promise((resolve10) => setTimeout(resolve10, CODE_RUN_POLL_INTERVAL_MS));
+        continue;
+      }
+      if (!response.ok) {
+        if (response.status >= SKILL_TASK_POLL_TRANSIENT_ERROR_STATUS2) {
+          lastTransientError = `HTTP ${response.status}`;
+          await new Promise((resolve10) => setTimeout(resolve10, CODE_RUN_POLL_INTERVAL_MS));
+          continue;
+        }
+        throw new OpenMatesApiError(response.status, await this.safeJson(response));
+      }
+      lastTransientError = null;
+      const status = await this.parseResponse(response);
+      const value = typeof status.status === "string" ? status.status : "";
+      if (CODE_RUN_TERMINAL_STATUSES.has(value)) return status;
+      await new Promise((resolve10) => setTimeout(resolve10, CODE_RUN_POLL_INTERVAL_MS));
+    }
+    if (lastTransientError) {
+      throw new Error(`Code Run did not complete within ${CODE_RUN_POLL_TIMEOUT_MS / 1e3}s; last polling error: ${lastTransientError}`);
+    }
+    throw new Error(`Code Run did not complete within ${CODE_RUN_POLL_TIMEOUT_MS / 1e3}s`);
+  }
+  normalizeCodeRunStatusPath(statusPath) {
+    if (!statusPath.startsWith("/v1/code/run/")) {
+      throw new OpenMatesConfigError("Code Run returned an invalid status path.");
+    }
+    return statusPath;
+  }
   async pollTaskUntilComplete(taskId) {
     const started = Date.now();
     let lastTransientError = null;
@@ -25987,6 +26380,8 @@ var HEARTBEAT_AFTER_MS = 24 * 60 * 60 * 1e3;
 var OPERATIONAL_REPORT_STALE_AFTER_MS = 26 * 60 * 60 * 1e3;
 var ALLOWED_WEBHOOK_PORTS = /* @__PURE__ */ new Set([443]);
 var IMMEDIATE_FAILURE_CLASSES = /* @__PURE__ */ new Set(["credential", "configuration", "config", "critical_availability"]);
+var BREVO_API_HOST = "api.brevo.com";
+var BREVO_REQUEST_TIMEOUT_MS = 1e4;
 function planOperationalMonitoring(options) {
   const emailEnabled = Boolean(options.adminEmail?.trim()) && options.emailServiceAvailable;
   const configurationStatus = !options.adminEmail?.trim() ? "missing_admin_email" : options.emailServiceAvailable ? "ready" : "email_service_unavailable";
@@ -26078,17 +26473,49 @@ function buildOperationalDeliveryReceipt(input) {
 }
 async function probeRuntimeEmailService(config) {
   try {
-    const response = await fetch("https://api.brevo.com/v3/account", {
-      method: "GET",
-      redirect: "error",
-      headers: { "api-key": config.apiKey },
-      signal: AbortSignal.timeout(1e4)
-    });
-    return response.ok;
+    await requestBrevo("/v3/account", "GET", config.apiKey);
+    return true;
   } catch {
     return false;
   }
 }
+function buildBrevoRequestOptions(pathName, method, apiKey, body) {
+  return {
+    protocol: "https:",
+    hostname: BREVO_API_HOST,
+    servername: BREVO_API_HOST,
+    port: 443,
+    path: pathName,
+    method,
+    family: 4,
+    lookup: (hostname, options, callback) => dnsModule.lookup(hostname, { ...options, family: 4 }, callback),
+    headers: {
+      "api-key": apiKey,
+      ...body ? { "content-type": "application/json", "Content-Length": Buffer.byteLength(body) } : {}
+    },
+    timeout: BREVO_REQUEST_TIMEOUT_MS
+  };
+}
+async function requestBrevo(pathName, method, apiKey, payload) {
+  const body = payload ? JSON.stringify(payload) : void 0;
+  await new Promise((resolve10, reject) => {
+    const request = httpsRequest(buildBrevoRequestOptions(pathName, method, apiKey, body), (response) => {
+      let responseBytes = 0;
+      response.on("data", (chunk) => {
+        responseBytes += chunk.length;
+        if (responseBytes > 64 * 1024) request.destroy(new Error("brevo_response_too_large"));
+      });
+      response.on("end", () => {
+        const status = response.statusCode ?? 0;
+        if (status >= 200 && status < 300) resolve10();
+        else reject(new Error(`brevo_delivery_failed:${status}`));
+      });
+    });
+    request.on("timeout", () => request.destroy(new Error("brevo_delivery_timeout")));
+    request.on("error", reject);
+    request.end(body);
+  });
+}
 async function readOperationalReportState(installDir, role) {
   const statePath = path.join(installDir, ".openmates", "runtime-health", `${role}-operational-report.json`);
   try {
@@ -26262,21 +26689,14 @@ async function sendDiscordWebhook(target, payload) {
   if (!response.ok) throw new Error(`discord_delivery_failed:${response.status}`);
 }
 async function sendRuntimeEmail(config, payload) {
-  const response = await fetch("https://api.brevo.com/v3/smtp/email", {
-    method: "POST",
-    redirect: "error",
-    headers: { "api-key": config.apiKey, "content-type": "application/json" },
-    body: JSON.stringify({
-      sender: { email: config.from },
-      to: [{ email: config.to }],
-      subject: `[OpenMates ${payload.role}] ${payload.kind}`,
-      textContent: `${payload.sanitizedReason}
+  await requestBrevo("/v3/smtp/email", "POST", config.apiKey, {
+    sender: { email: config.from },
+    to: [{ email: config.to }],
+    subject: `[OpenMates ${payload.role}] ${payload.kind}`,
+    textContent: `${payload.sanitizedReason}
 Checks: ${payload.checkIds.join(", ")}
 Time: ${payload.occurredAt}`
-    }),
-    signal: AbortSignal.timeout(1e4)
   });
-  if (!response.ok) throw new Error(`email_delivery_failed:${response.status}`);
 }
 async function deliverWithRetries(channel, send) {
   for (let attempt = 1; attempt <= 3; attempt += 1) {
@@ -30004,6 +30424,28 @@ function buildCodeRunStreamUrl(params) {
   const query = new URLSearchParams({ sessionId: params.sessionId, token: params.token });
   return `${base}/v1/code/run/${encodeURIComponent(params.executionId)}/stream?${query.toString()}`;
 }
+function formatCodeRunFinalStatusOutput(status, options = {}) {
+  let output = "";
+  if (options.includeOutput !== false && typeof status.output === "string" && status.output.length > 0) {
+    output += status.output.endsWith("\n") ? status.output : `${status.output}
+`;
+  }
+  const artifactLines = formatCodeRunArtifactLines(status.artifacts);
+  if (artifactLines.length > 0) {
+    if (output.length > 0 && !output.endsWith("\n\n")) output += "\n";
+    output += `Artifacts:
+${artifactLines.join("\n")}
+`;
+  }
+  const skippedLines = formatCodeRunSkippedArtifactLines(status.skipped_artifacts);
+  if (skippedLines.length > 0) {
+    if (output.length > 0 && !output.endsWith("\n\n")) output += "\n";
+    output += `Skipped artifacts:
+${skippedLines.join("\n")}
+`;
+  }
+  return output;
+}
 function normalizeCodeRunPath(rawPath) {
   const path2 = rawPath.trim().replace(/\\/g, "/");
   if (!path2 || path2.includes("\0") || path2.startsWith("/") || path2.startsWith("~/") || /^[A-Za-z]:\//.test(path2)) {
@@ -30059,6 +30501,31 @@ function toList(value) {
   if (typeof value === "string") return value.split("\n").filter(Boolean);
   return [];
 }
+function formatCodeRunArtifactLines(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item)).map((artifact) => {
+    const path2 = stringValue(artifact.normalized_path) || stringValue(artifact.path) || "artifact";
+    const mimeType = stringValue(artifact.mime_type) || "application/octet-stream";
+    const sizeBytes = numberValue2(artifact.size_bytes);
+    const size = sizeBytes === null ? "unknown size" : `${sizeBytes} bytes`;
+    const downloadUrl = stringValue(artifact.download_url);
+    return downloadUrl ? `- ${path2} (${mimeType}, ${size}): ${downloadUrl}` : `- ${path2} (${mimeType}, ${size})`;
+  });
+}
+function formatCodeRunSkippedArtifactLines(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item)).map((artifact) => {
+    const path2 = stringValue(artifact.normalized_path) || stringValue(artifact.path) || "artifact";
+    const reason = stringValue(artifact.reason) || "skipped";
+    return `- ${path2} (${reason})`;
+  });
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function matchesAny(path2, patterns) {
   return patterns.some((pattern) => matchesPattern(path2, pattern));
 }
@@ -47055,7 +47522,7 @@ function stripQuotes(value) {
   }
   return value;
 }
-function numberValue2(value) {
+function numberValue3(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value !== "string" || value.trim() === "") return null;
   const parsed = Number(value);
@@ -47216,11 +47683,11 @@ function plural(value, singular, pluralLabel = `${singular}s`) {
 }
 function buildMetadata(nodeType, type, record) {
   const parts = [labelForNodeType(nodeType, type)];
-  const lineCount = numberValue2(record.line_count ?? record.lineCount);
-  const pageCount = numberValue2(record.page_count ?? record.pageCount);
-  const wordCount = numberValue2(record.word_count ?? record.wordCount);
-  const duration = numberValue2(record.duration_seconds ?? record.durationSeconds);
-  const size = numberValue2(record.byte_length ?? record.size_bytes ?? record.sizeBytes);
+  const lineCount = numberValue3(record.line_count ?? record.lineCount);
+  const pageCount = numberValue3(record.page_count ?? record.pageCount);
+  const wordCount = numberValue3(record.word_count ?? record.wordCount);
+  const duration = numberValue3(record.duration_seconds ?? record.durationSeconds);
+  const size = numberValue3(record.byte_length ?? record.size_bytes ?? record.sizeBytes);
   if (lineCount) parts.push(plural(lineCount, "line"));
   if (pageCount) parts.push(plural(pageCount, "page"));
   if (wordCount) parts.push(plural(wordCount, "word"));
@@ -47317,7 +47784,7 @@ function getEmbedFileReferences(embed) {
   const nodeType = inferNodeType(title, type);
   const url = urlForType(type, decoded);
   const mimeType = stringField2(decoded, ["mime_type", "file_type", "mimeType"]);
-  const createdAt = numberValue2(embed.created_at ?? embed.createdAt) ?? 0;
+  const createdAt = numberValue3(embed.created_at ?? embed.createdAt) ?? 0;
   return [{
     embedId: normalizeEmbedId(embedId),
     contentRef: `embed:${normalizeEmbedId(embedId)}`,
@@ -48816,6 +49283,21 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
         hide_output: {
           text: "Hide output"
         },
+        artifacts: {
+          text: "Generated files"
+        },
+        skipped_artifacts: {
+          text: "Skipped files"
+        },
+        download_artifact: {
+          text: "Download"
+        },
+        download_unavailable: {
+          text: "Download expired"
+        },
+        previous_versions: {
+          text: "Previous versions"
+        },
         hide_files: {
           text: "Hide files"
         },
@@ -74697,12 +75179,12 @@ async function handleProjectFiles(client, masterKey, rest, flags, context) {
   printProjectFileResult(action, project.projectId, source.source_id, result, flags);
 }
 var CliContractError = class extends Error {
+  code;
   constructor(code, message) {
     super(message);
     this.code = code;
     this.name = "CliContractError";
   }
-  code;
 };
 function hasExplicitProjectContext(flags) {
   return flags.personal === true || typeof flags.team === "string" || typeof flags["team-id"] === "string";
@@ -78264,7 +78746,9 @@ async function handleCodeRun(client, flags, apiKey) {
   }
   const streamAuth = apiKey ? null : await client.getCodeRunStreamAuth();
   let finalStatus;
+  let usedStream = false;
   if (streamAuth && result.stream_path) {
+    usedStream = true;
     const url = buildCodeRunStreamUrl({
       apiUrl: client.apiUrl,
       executionId: result.execution_id,
@@ -78288,6 +78772,9 @@ async function handleCodeRun(client, flags, apiKey) {
   }
   if (flags.json === true) {
     printJson2({ ...result, final: finalStatus });
+  } else {
+    const finalOutput = formatCodeRunFinalStatusOutput(finalStatus, { includeOutput: !usedStream });
+    if (finalOutput) process.stdout.write(finalOutput);
   }
 }
 async function streamCodeRunToTerminal(url, jsonMode) {

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   requireExactConfirmation,
   resolveProjectContext,
   serializeToYaml
-} from "./chunk-BNHR25YW.js";
+} from "./chunk-TNSNIRLS.js";
 import "./chunk-IWKP55ZB.js";
 import "./chunk-WBBDQZZI.js";
 export {

package/dist/index.d.ts

@@ -34,6 +34,17 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["prompt"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly answer: {
+                readonly type: "string";
+            };
+            readonly conversation: {
+                readonly type: "string";
+            };
+        };
+    };
 }, {
     readonly app_id: "audio";
     readonly skill_id: "generate";
@@ -250,6 +261,23 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["companies"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+            };
+            readonly result_count: {
+                readonly type: "integer";
+            };
+            readonly provider: {
+                readonly type: "string";
+            };
+            readonly results: {
+                readonly type: "array";
+            };
+        };
+    };
 }, {
     readonly app_id: "code";
     readonly skill_id: "search_repos";
@@ -309,6 +337,236 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["library", "question"];
     };
+}, {
+    readonly app_id: "code";
+    readonly skill_id: "run";
+    readonly app_namespace_ts: "code";
+    readonly skill_method_ts: "run";
+    readonly app_namespace_py: "code";
+    readonly skill_method_py: "run";
+    readonly description_key: "app_skills.code.run.description";
+    readonly description: "Run a code embed in an isolated E2B sandbox. Use automatically only for code the assistant created or edited in the current turn; ask the user before running unmodified user-supplied code or after the initial run plus two unprompted reruns. The sandbox receives code files from the current chat, installs supported dependency manifests, executes the selected file, streams terminal status, and returns safe artifact metadata. Pricing is 5 credits per started minute of sandbox runtime.";
+    readonly schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly requests: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 10;
+                readonly description: "Array of direct or chat-bound Code Run requests for the custom REST/SDK route.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly mode: {
+                            readonly type: "string";
+                            readonly enum: readonly ["direct", "chat_bound"];
+                            readonly default: "direct";
+                            readonly description: "Direct runs use caller-supplied files and stay transient; chat_bound runs use a chat/embed target and persist encrypted output.";
+                        };
+                        readonly entry_path: {
+                            readonly type: "string";
+                            readonly description: "Entrypoint file path for direct runs.";
+                        };
+                        readonly files: {
+                            readonly type: "array";
+                            readonly maxItems: 50;
+                            readonly description: "Direct-run files with base64-encoded content. The backend never fetches local paths or URLs.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly path: {
+                                        readonly type: "string";
+                                    };
+                                    readonly content_base64: {
+                                        readonly type: "string";
+                                    };
+                                    readonly language: {
+                                        readonly type: "string";
+                                    };
+                                    readonly mime_type: {
+                                        readonly type: "string";
+                                        readonly default: "text/plain";
+                                    };
+                                    readonly is_target: {
+                                        readonly type: "boolean";
+                                        readonly default: false;
+                                    };
+                                };
+                                readonly required: readonly ["path", "content_base64"];
+                            };
+                        };
+                        readonly chat_id: {
+                            readonly type: "string";
+                            readonly description: "Chat ID for chat-bound runs.";
+                        };
+                        readonly target_embed_id: {
+                            readonly type: "string";
+                            readonly description: "Target code embed ID for chat-bound runs.";
+                        };
+                        readonly selected_embed_ids: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly description: "Optional related embed IDs to include in chat-bound runs.";
+                        };
+                        readonly dependency_installs: {
+                            readonly type: "array";
+                            readonly maxItems: 20;
+                            readonly description: "Optional explicit dependency installs.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly ecosystem: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["python", "npm"];
+                                    };
+                                    readonly packages: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly required: readonly ["ecosystem", "packages"];
+                            };
+                        };
+                        readonly enable_internet: {
+                            readonly type: "boolean";
+                            readonly default: true;
+                            readonly description: "Allow outbound internet access from the E2B sandbox.";
+                        };
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["requests"];
+    };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly results: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly execution_id: {
+                            readonly type: "string";
+                        };
+                        readonly status: {
+                            readonly type: "string";
+                        };
+                        readonly target_filename: {
+                            readonly type: "string";
+                        };
+                        readonly files: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly credits_per_minute: {
+                            readonly type: "integer";
+                        };
+                        readonly persisted_output: {
+                            readonly type: "boolean";
+                        };
+                        readonly stream_path: {
+                            readonly type: "string";
+                        };
+                        readonly status_path: {
+                            readonly type: "string";
+                        };
+                        readonly final: {
+                            readonly type: "object";
+                            readonly description: "Final status fetched from status_path by SDK helpers. Direct runs remain transient.";
+                            readonly properties: {
+                                readonly status: {
+                                    readonly type: "string";
+                                };
+                                readonly exit_code: {
+                                    readonly type: "integer";
+                                };
+                                readonly output: {
+                                    readonly type: "string";
+                                };
+                                readonly error: {
+                                    readonly type: "string";
+                                };
+                                readonly duration_seconds: {
+                                    readonly type: "number";
+                                };
+                                readonly charged_credits: {
+                                    readonly type: "integer";
+                                };
+                                readonly charged_minutes: {
+                                    readonly type: "integer";
+                                };
+                                readonly artifacts: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly properties: {
+                                            readonly path: {
+                                                readonly type: "string";
+                                            };
+                                            readonly normalized_path: {
+                                                readonly type: "string";
+                                            };
+                                            readonly mime_type: {
+                                                readonly type: "string";
+                                            };
+                                            readonly kind: {
+                                                readonly type: "string";
+                                            };
+                                            readonly size_bytes: {
+                                                readonly type: "integer";
+                                            };
+                                            readonly status: {
+                                                readonly type: "string";
+                                            };
+                                            readonly asset_id: {
+                                                readonly type: "string";
+                                            };
+                                            readonly file_id: {
+                                                readonly type: "string";
+                                            };
+                                            readonly variant: {
+                                                readonly type: "string";
+                                            };
+                                            readonly version: {
+                                                readonly type: "integer";
+                                            };
+                                            readonly download_url: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly skipped_artifacts: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly properties: {
+                                            readonly path: {
+                                                readonly type: "string";
+                                            };
+                                            readonly normalized_path: {
+                                                readonly type: "string";
+                                            };
+                                            readonly reason: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     readonly app_id: "code";
     readonly skill_id: "image_to_html";
@@ -654,6 +912,17 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["requests"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+            };
+            readonly result_count: {
+                readonly type: "integer";
+            };
+        };
+    };
 }, {
     readonly app_id: "fitness";
     readonly skill_id: "search_locations";
@@ -1428,6 +1697,17 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["requests"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+            };
+            readonly result_count: {
+                readonly type: "integer";
+            };
+        };
+    };
 }, {
     readonly app_id: "nutrition";
     readonly skill_id: "search_recipes";
@@ -2754,6 +3034,20 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["location"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+            };
+            readonly rain_probability: {
+                readonly type: "number";
+            };
+            readonly max_temperature_c: {
+                readonly type: "number";
+            };
+        };
+    };
 }, {
     readonly app_id: "weather";
     readonly skill_id: "rain_radar";
@@ -2850,6 +3144,17 @@ declare const APP_SKILL_METADATA: readonly [{
         };
         readonly required: readonly ["requests"];
     };
+    readonly output_schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+            };
+            readonly result_count: {
+                readonly type: "integer";
+            };
+        };
+    };
 }, {
     readonly app_id: "web";
     readonly skill_id: "read";
@@ -3041,6 +3346,12 @@ declare class CodeAppSkills {
      * Skill: code/remove_secrets
      */
     removeSecrets<T = unknown>(input: SkillInput, options?: AppSkillRunOptions): Promise<T>;
+    /**
+     * Run a code embed in an isolated E2B sandbox. Use automatically only for code the assistant created or edited in the current turn; ask the user before running unmodified user-supplied code or after the initial run plus two unprompted reruns. The sandbox receives code files from the current chat, installs supported dependency manifests, executes the selected file, streams terminal status, and returns safe artifact metadata. Pricing is 5 credits per started minute of sandbox runtime.
+     * Description key: app_skills.code.run.description
+     * Skill: code/run
+     */
+    run<T = unknown>(input: SkillInput, options?: AppSkillRunOptions): Promise<T>;
     /**
      * Search GitHub repositories. Use this instead of web.search whenever the user asks to find GitHub repos, repositories, open-source libraries, starred repos, or repo examples by topic, language, framework, or project need. Returns licensed repository embeds. Costs 10 credits per search.
      * Description key: code.search_repos.description
@@ -4266,6 +4577,9 @@ declare class OpenMates {
     private publicHeaders;
     private parseResponse;
     private resolveAsyncSkillResponse;
+    private resolveCodeRunSkillResponse;
+    private pollCodeRunUntilComplete;
+    private normalizeCodeRunStatusPath;
     private pollTaskUntilComplete;
     private safeJson;
     private wrapResolvedSkillResult;

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   renderPlanList,
   renderSupportInfo,
   serializeToYaml
-} from "./chunk-BNHR25YW.js";
+} from "./chunk-TNSNIRLS.js";
 import "./chunk-IWKP55ZB.js";
 import "./chunk-WBBDQZZI.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmates",
-  "version": "0.17.0-alpha.1",
+  "version": "0.17.0-alpha.3",
   "description": "OpenMates CLI and SDK",
   "type": "module",
   "main": "dist/index.js",