@mindstudio-ai/agent 0.1.93 → 0.1.95

package/dist/cli.js

@@ -3741,7 +3741,8 @@ async function runTaskPoll(httpConfig, body) {
     const res = await fetch(pollUrl, {
       headers: { "User-Agent": "@mindstudio-ai/agent" }
     });
-    if (res.status === 502 || res.status === 503 || res.status === 504) continue;
+    if (res.status === 502 || res.status === 503 || res.status === 504)
+      continue;
     if (res.status === 404) {
       throw new MindStudioError(
         "Task poll token not found or expired.",
@@ -3761,7 +3762,9 @@ async function runTaskPoll(httpConfig, body) {
     const poll = await res.json();
     if (poll.status === "pending") {
       if (isDevMode() && poll.currentTurn != null) {
-        console.log(`[task] running... turn ${poll.currentTurn}/${poll.maxTurns ?? "?"}`);
+        console.log(
+          `[task] running... turn ${poll.currentTurn}/${poll.maxTurns ?? "?"}`
+        );
       }
       continue;
     }
@@ -3777,7 +3780,11 @@ async function runTaskPoll(httpConfig, body) {
       outputRaw: poll.outputRaw ?? "",
       parsedSuccessfully: poll.parsedSuccessfully ?? true,
       turns: poll.turns ?? 0,
-      usage: poll.usage ?? { inputTokens: 0, outputTokens: 0, totalBillingCost: 0 },
+      usage: poll.usage ?? {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalBillingCost: 0
+      },
       toolCalls: poll.toolCalls ?? []
     };
     logTaskResult(result);
@@ -3906,6 +3913,405 @@ var init_task = __esm({
   }
 });
 
+// src/task/local.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function mergeToolInput(modelInput, defaults) {
+  const merged = { ...modelInput };
+  for (const [key, defaultValue] of Object.entries(defaults)) {
+    if (UNSAFE_KEYS.has(key)) {
+      continue;
+    }
+    const modelValue = merged[key];
+    merged[key] = isPlainObject(defaultValue) && isPlainObject(modelValue) ? mergeToolInput(modelValue, defaultValue) : defaultValue;
+  }
+  return merged;
+}
+function truncateToolOutput(output) {
+  const serialized = JSON.stringify(output);
+  return serialized && serialized.length > MAX_TOOL_OUTPUT_CHARS ? serialized.slice(0, MAX_TOOL_OUTPUT_CHARS) + "... [truncated]" : output;
+}
+async function attemptTurn(httpConfig, body) {
+  const url = `${httpConfig.baseUrl}/developer/v2/task/turn`;
+  await httpConfig.rateLimiter.acquire();
+  try {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${httpConfig.token}`,
+          "Content-Type": "application/json",
+          "User-Agent": "@mindstudio-ai/agent",
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new TurnError(
+        `Network error: ${err instanceof Error ? err.message : "fetch failed"}`,
+        true,
+        "request"
+      );
+    }
+    httpConfig.rateLimiter.updateFromHeaders(res.headers);
+    if (!res.ok) {
+      let message = `${res.status} ${res.statusText}`;
+      let code;
+      try {
+        const errBody = await res.json();
+        const errMsg = (typeof errBody.errorMessage === "string" ? errBody.errorMessage : void 0) ?? (typeof errBody.errorString === "string" ? errBody.errorString : void 0) ?? (typeof errBody.error === "string" ? errBody.error : void 0);
+        if (errMsg) message = errMsg;
+        if (typeof errBody.errorString === "string") code = errBody.errorString;
+      } catch {
+      }
+      const retryable = res.status >= 500 || res.status === 429;
+      throw new TurnError(message, retryable, "request", res.status, code);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const events = [];
+    let text = "";
+    const toolCalls = [];
+    let turn = null;
+    const handleLine = (line) => {
+      if (!line.startsWith("data: ")) {
+        return;
+      }
+      let event;
+      try {
+        event = JSON.parse(line.slice(6));
+      } catch {
+        return;
+      }
+      if (event.type === "error") {
+        const status = typeof event.status === "number" ? event.status : 500;
+        const message = typeof event.error === "string" ? event.error : "Model call failed";
+        const retryable = status >= 500 || /overloaded|terminated|network/i.test(message);
+        throw new TurnError(message, retryable, "model", status);
+      }
+      if (event.type === "turn") {
+        turn = {
+          events,
+          text,
+          toolCalls,
+          stopReason: typeof event.stopReason === "string" ? event.stopReason : "end_turn",
+          usage: event.usage ?? {},
+          billingCost: typeof event.billingCost === "number" ? event.billingCost : 0
+        };
+        return;
+      }
+      if (event.type === "text" && typeof event.text === "string") {
+        text += event.text;
+      } else if (event.type === "tool_use") {
+        toolCalls.push({
+          id: event.id,
+          name: event.name,
+          input: event.input ?? {}
+        });
+      }
+      events.push(event);
+    };
+    while (true) {
+      let stallTimer;
+      let readResult;
+      try {
+        readResult = await Promise.race([
+          reader.read(),
+          new Promise((_, reject) => {
+            stallTimer = setTimeout(
+              () => reject(new Error("stream_stall")),
+              STALL_TIMEOUT_MS
+            );
+          })
+        ]);
+        clearTimeout(stallTimer);
+      } catch (err) {
+        clearTimeout(stallTimer);
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        if (err instanceof TurnError) {
+          throw err;
+        }
+        const isStall = err instanceof Error && err.message === "stream_stall";
+        throw new TurnError(
+          isStall ? "Turn stalled \u2014 no data received for 5 minutes" : `Network error: stream interrupted \u2014 ${err instanceof Error ? err.message : "unknown"}`,
+          true,
+          "request"
+        );
+      }
+      if (readResult.done) {
+        break;
+      }
+      buffer += decoder.decode(readResult.value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        handleLine(line);
+      }
+    }
+    if (buffer) {
+      handleLine(buffer);
+    }
+    if (!turn) {
+      throw new TurnError(
+        "Network error: stream ended before turn completion",
+        true,
+        "request"
+      );
+    }
+    return turn;
+  } finally {
+    httpConfig.rateLimiter.release();
+  }
+}
+async function runTurnWithRetry(httpConfig, body) {
+  for (let attempt = 0; attempt < MAX_TURN_ATTEMPTS; attempt++) {
+    try {
+      return await attemptTurn(httpConfig, body);
+    } catch (err) {
+      if (!(err instanceof TurnError) || !err.retryable || attempt >= MAX_TURN_ATTEMPTS - 1) {
+        throw err;
+      }
+      if (isDevMode()) {
+        console.log(
+          `[task] connection lost, retrying turn (attempt ${attempt + 2} of ${MAX_TURN_ATTEMPTS})`
+        );
+      }
+      await sleep2(INITIAL_BACKOFF_MS * 2 ** attempt);
+    }
+  }
+  throw new TurnError("Turn retries exhausted", false, "request");
+}
+async function runTaskLocal(deps, options) {
+  const { httpConfig } = deps;
+  const onEvent = options.onEvent;
+  const structuredOutputExample = typeof options.structuredOutputExample === "string" ? options.structuredOutputExample : JSON.stringify(options.structuredOutputExample);
+  const system = `${options.prompt}
+
+When you have completed the task, respond with your final output as JSON matching this example:
+${structuredOutputExample}
+<!-- cache_breakpoint -->`;
+  const wireTools = mapTools(options.tools);
+  const toolKinds = /* @__PURE__ */ new Map();
+  const toolDefaults = /* @__PURE__ */ new Map();
+  for (const t of wireTools) {
+    if ("appMethod" in t) {
+      toolKinds.set(t.appMethod, "method");
+      if (t.defaults) toolDefaults.set(t.appMethod, t.defaults);
+    } else {
+      toolKinds.set(t.stepType, "step");
+      if (t.defaults) toolDefaults.set(t.stepType, t.defaults);
+    }
+  }
+  const maxTurns = Math.min(
+    Math.max(options.maxTurns || DEFAULT_MAX_TURNS, 1),
+    MAX_TURNS_LIMIT
+  );
+  const messages = [
+    { role: "user", content: JSON.stringify(options.input) }
+  ];
+  let loopCount = 0;
+  const toolCallLog = [];
+  const totalUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    totalBillingCost: 0
+  };
+  const buildResult = (output2, outputRaw, parsedSuccessfully2, turns) => ({
+    output: output2,
+    outputRaw,
+    parsedSuccessfully: parsedSuccessfully2,
+    turns,
+    usage: totalUsage,
+    toolCalls: toolCallLog
+  });
+  const accumulate = (turn) => {
+    totalUsage.inputTokens += turn.usage.inputTokens ?? 0;
+    totalUsage.outputTokens += turn.usage.outputTokens ?? 0;
+    totalUsage.cacheCreationTokens += turn.usage.cacheCreationTokens ?? 0;
+    totalUsage.cacheReadTokens += turn.usage.cacheReadTokens ?? 0;
+    totalUsage.totalBillingCost += turn.billingCost;
+    for (const event of turn.events) {
+      onEvent?.(event);
+    }
+  };
+  const finish = (result) => {
+    onEvent?.({ type: "done", ...result });
+    logTaskResult(result);
+    return result;
+  };
+  const turnFailure = (err) => {
+    if (err instanceof TurnError && err.phase === "model") {
+      if (isDevMode()) {
+        console.error(`[task] Model call failed: ${err.message}`);
+      }
+      return finish(buildResult(null, "", false, loopCount));
+    }
+    if (err instanceof TurnError) {
+      throw new MindStudioError(
+        `[task] ${err.message}`,
+        err.errorCode ?? "task_turn_error",
+        err.status ?? 500
+      );
+    }
+    throw err;
+  };
+  while (loopCount < maxTurns) {
+    loopCount++;
+    let turn;
+    try {
+      turn = await runTurnWithRetry(httpConfig, {
+        model: options.model,
+        system,
+        messages,
+        tools: wireTools
+      });
+    } catch (err) {
+      if (loopCount === 1 && err instanceof TurnError && err.status === 404 && err.errorCode === "not_found") {
+        throw new MindStudioError(
+          "Task turn endpoint unavailable.",
+          TURN_UNAVAILABLE_CODE,
+          404
+        );
+      }
+      return turnFailure(err);
+    }
+    accumulate(turn);
+    if (turn.stopReason === "tool_use" && turn.toolCalls.length > 0) {
+      messages.push({
+        role: "assistant",
+        content: turn.text,
+        toolCalls: turn.toolCalls
+      });
+      const results = await Promise.all(
+        turn.toolCalls.map(async (toolCall) => {
+          onEvent?.({
+            type: "tool_call_start",
+            id: toolCall.id,
+            name: toolCall.name
+          });
+          const startTime = Date.now();
+          const defaults = toolDefaults.get(toolCall.name) || {};
+          const mergedInput = mergeToolInput(toolCall.input, defaults);
+          const execute = toolKinds.get(toolCall.name) === "method" ? deps.executeMethodTool : deps.executeStepTool;
+          const result = await execute(toolCall.name, mergedInput);
+          toolCallLog.push({
+            name: toolCall.name,
+            success: !result.isError,
+            durationMs: Date.now() - startTime
+          });
+          return { toolCall, ...result };
+        })
+      );
+      for (const { toolCall, output: output2, billingCost, isError } of results) {
+        if (billingCost) {
+          totalUsage.totalBillingCost += billingCost;
+        }
+        const truncated = truncateToolOutput(output2);
+        messages.push({
+          role: "user",
+          content: JSON.stringify(truncated),
+          toolCallId: toolCall.id,
+          ...isError && { isToolError: true }
+        });
+        onEvent?.({
+          type: "tool_call_result",
+          id: toolCall.id,
+          output: truncated
+        });
+      }
+      if (isDevMode()) {
+        console.log(`[task] running... turn ${loopCount}/${maxTurns}`);
+      }
+      continue;
+    }
+    messages.push({ role: "assistant", content: turn.text });
+    try {
+      const output2 = JSON.parse(turn.text);
+      return finish(buildResult(output2, turn.text, true, loopCount));
+    } catch {
+      if (loopCount < maxTurns) {
+        messages.push({
+          role: "user",
+          content: "Your response was not valid JSON. Please respond with ONLY the JSON output, no other text."
+        });
+        continue;
+      }
+    }
+    return finish(buildResult(turn.text, turn.text, false, loopCount));
+  }
+  messages.push({
+    role: "user",
+    content: "You have reached the maximum number of turns. Please provide your final output now as JSON."
+  });
+  let finalText = "";
+  try {
+    const turn = await runTurnWithRetry(httpConfig, {
+      model: options.model,
+      system,
+      messages,
+      tools: []
+    });
+    accumulate(turn);
+    finalText = turn.text;
+  } catch (err) {
+    if (err instanceof TurnError && err.phase === "model") {
+      if (isDevMode()) {
+        console.error(`[task] Final model call failed: ${err.message}`);
+      }
+    } else {
+      return turnFailure(err);
+    }
+  }
+  let parsedSuccessfully = true;
+  let output;
+  try {
+    output = JSON.parse(finalText);
+  } catch {
+    output = finalText;
+    parsedSuccessfully = false;
+  }
+  return finish(
+    buildResult(output, finalText, parsedSuccessfully, loopCount + 1)
+  );
+}
+var DEFAULT_MAX_TURNS, MAX_TURNS_LIMIT, MAX_TOOL_OUTPUT_CHARS, MAX_TURN_ATTEMPTS, INITIAL_BACKOFF_MS, STALL_TIMEOUT_MS, TURN_UNAVAILABLE_CODE, UNSAFE_KEYS, TurnError;
+var init_local = __esm({
+  async "src/task/local.ts"() {
+    "use strict";
+    init_errors();
+    await init_task();
+    DEFAULT_MAX_TURNS = 20;
+    MAX_TURNS_LIMIT = 100;
+    MAX_TOOL_OUTPUT_CHARS = 5e4;
+    MAX_TURN_ATTEMPTS = 5;
+    INITIAL_BACKOFF_MS = 1e3;
+    STALL_TIMEOUT_MS = 3e5;
+    TURN_UNAVAILABLE_CODE = "task_turn_unavailable";
+    UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+    TurnError = class extends Error {
+      constructor(message, retryable, phase, status, errorCode) {
+        super(message);
+        this.retryable = retryable;
+        this.phase = phase;
+        this.status = status;
+        this.errorCode = errorCode;
+      }
+    };
+  }
+});
+
 // src/generated/steps.ts
 var steps_exports = {};
 __export(steps_exports, {
@@ -4474,6 +4880,7 @@ var init_client = __esm({
     init_datasources();
     init_voice();
     await init_task();
+    await init_local();
     init_steps();
     init_metadata();
     DEFAULT_BASE_URL = "https://v1.mindstudio-api.com";
@@ -4608,8 +5015,8 @@ var init_client = __esm({
           ...options?.appId != null && { appId: options.appId },
           ...threadId != null && { threadId },
           ...this._currentStreamId != null && { streamId: this._currentStreamId },
-          ...this._requestSource != null && {
-            requestSource: this._requestSource
+          ...(options?.requestSource ?? this._requestSource) != null && {
+            requestSource: options?.requestSource ?? this._requestSource
           },
           ...assetStoreBody(options?.store)
         });
@@ -4695,8 +5102,8 @@ var init_client = __esm({
           ...options.appId != null && { appId: options.appId },
           ...threadId != null && { threadId },
           ...this._currentStreamId != null && { streamId: this._currentStreamId },
-          ...this._requestSource != null && {
-            requestSource: this._requestSource
+          ...(options.requestSource ?? this._requestSource) != null && {
+            requestSource: options.requestSource ?? this._requestSource
           },
           ...assetStoreBody(options.store)
         };
@@ -4998,11 +5405,135 @@ var init_client = __esm({
        * ```
        */
       async runTask(options) {
-        const body = buildTaskRequestBody(options);
-        if (options.onEvent) {
-          return runTaskStream(this._currentHttpConfig, body, options.onEvent);
+        const taskPromise = this._runTaskInner(options);
+        const hook = globalThis.__msWaitUntil;
+        if (typeof hook === "function") {
+          try {
+            hook(taskPromise.catch(() => {
+            }));
+          } catch {
+          }
+        }
+        return taskPromise;
+      }
+      /**
+       * Register background work with the platform so the sandbox stays alive
+       * until it settles (bounded at ~30 minutes) instead of being reaped as
+       * idle, and so an interruption is recorded in the request log if the
+       * sandbox is torn down anyway.
+       *
+       * Use it for the fire-and-forget pattern — kick off slow work, return
+       * early, write results back when it finishes:
+       *
+       * ```ts
+       * mindstudio.waitUntil(
+       *   enrichRecord(id)
+       *     .then((data) => Records.update(id, { ...data, status: 'ready' }))
+       *     .catch(() => Records.update(id, { status: 'failed' })),
+       * );
+       * return { status: 'processing' };
+       * ```
+       *
+       * Failures of the registered promise are caught and logged to the request
+       * log — they can never crash the sandbox. Outside a managed sandbox this
+       * degrades to just that error-catching. If you need the result, keep your
+       * own reference to the promise and `await` it — `waitUntil` returns void.
+       */
+      waitUntil(promise) {
+        const caught = Promise.resolve(promise).catch((err) => {
+          console.error(
+            "[waitUntil] Background work failed:",
+            err instanceof Error ? err.stack ?? err.message : String(err)
+          );
+        });
+        const hook = globalThis.__msWaitUntil;
+        if (typeof hook === "function") {
+          try {
+            hook(caught);
+          } catch {
+          }
+        }
+      }
+      async _runTaskInner(options) {
+        const httpConfig = this._currentHttpConfig;
+        try {
+          return await runTaskLocal(
+            {
+              httpConfig,
+              executeStepTool: async (stepType, input) => {
+                try {
+                  const result = await this.executeStep(stepType, input, {
+                    requestSource: "v2-task"
+                  });
+                  const output = {};
+                  let billingCost = 0;
+                  for (const [key, value] of Object.entries(
+                    result
+                  )) {
+                    if (key === "$billingCost" && typeof value === "number") {
+                      billingCost = value;
+                    }
+                    if (!key.startsWith("$")) {
+                      output[key] = value;
+                    }
+                  }
+                  return { output, billingCost, isError: false };
+                } catch (err) {
+                  return {
+                    output: {
+                      error: err instanceof Error ? err.message : "Step execution failed"
+                    },
+                    billingCost: 0,
+                    isError: true
+                  };
+                }
+              },
+              executeMethodTool: async (methodId, input) => {
+                try {
+                  const { data } = await request(
+                    { ...httpConfig, maxRetries: 0 },
+                    "POST",
+                    "/task/invoke-method",
+                    {
+                      methodId,
+                      input
+                    }
+                  );
+                  if (data.error) {
+                    return {
+                      output: { error: data.error },
+                      billingCost: 0,
+                      isError: true
+                    };
+                  }
+                  return {
+                    output: data.output ?? null,
+                    billingCost: 0,
+                    isError: false
+                  };
+                } catch (err) {
+                  return {
+                    output: {
+                      error: err instanceof Error ? err.message : "Method execution failed"
+                    },
+                    billingCost: 0,
+                    isError: true
+                  };
+                }
+              }
+            },
+            options
+          );
+        } catch (err) {
+          if (err instanceof MindStudioError && err.code === TURN_UNAVAILABLE_CODE) {
+            const body = buildTaskRequestBody(options);
+            if (options.onEvent) {
+              return runTaskStream(httpConfig, body, options.onEvent);
+            }
+            return runTaskPoll(httpConfig, body);
+          }
+          throw err;
         }
-        return runTaskPoll(this._currentHttpConfig, body);
       }
       /**
        * Get the authenticated user's identity and organization info.
@@ -6802,7 +7333,7 @@ async function startMcpServer(options) {
           capabilities: { tools: {} },
           serverInfo: {
             name: "mindstudio-agent",
-            version: "0.1.93"
+            version: "0.1.95"
           },
           instructions: 'Welcome to MindStudio \u2014 a platform with 200+ AI models, 850+ third-party integrations, and pre-built agents.\n\nGetting started:\n1. Call `ask` with any question about the SDK \u2014 it knows every action, model, and connector and returns working code with real model IDs and config options. Examples: ask("generate an image with FLUX"), ask("what models support vision?"), ask("how do I send a Slack message?").\n2. Call `changeName` to set your display name \u2014 use your name or whatever your user calls you. This is how you\'ll appear in MindStudio request logs.\n3. If you have a profile picture, pass its public image URL to `changeProfilePicture`.\n4. For manual browsing, call `listActions` to discover all available actions.\n\nThen use the tools to generate text, images, video, audio, search the web, work with data sources, run agents, and more.\n\nImportant:\n- AI-powered actions (text generation, image generation, video, audio, etc.) cost money. Before running these, call `estimateActionCost` and confirm with the user before proceeding \u2014 unless they\'ve explicitly told you to go ahead.\n- Not all agents from `listAgents` are configured for API use. Do not try to run an agent just because it appears in the list \u2014 it will likely fail. Only run agents the user specifically asks you to run.'
         });
@@ -7787,7 +8318,7 @@ function isNewerVersion(current, latest) {
   return false;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.93";
+  const currentVersion = "0.1.95";
   if (!currentVersion) return null;
   try {
     const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -7816,7 +8347,7 @@ async function checkForUpdate() {
   }
 }
 function printUpdateNotice(latestVersion) {
-  const currentVersion = "0.1.93";
+  const currentVersion = "0.1.95";
   process.stderr.write(
     `
   ${ansi2.cyanBright("Update available")} ${ansi2.gray(currentVersion + " \u2192")} ${ansi2.cyanBold(latestVersion)}
@@ -7829,7 +8360,7 @@ function isStandaloneBinary() {
   return !argv1.includes("node_modules");
 }
 async function cmdUpdate() {
-  const currentVersion = "0.1.93";
+  const currentVersion = "0.1.95";
   process.stderr.write(
     `  ${ansi2.gray("Current version:")} ${currentVersion}
 `
@@ -7964,7 +8495,7 @@ async function cmdLogin(options) {
   process.stderr.write("\n");
   printLogo();
   process.stderr.write("\n");
-  const ver = "0.1.93";
+  const ver = "0.1.95";
   process.stderr.write(
     `  ${ansi2.bold("MindStudio Agent")} ${ver ? " " + ansi2.gray("v" + ver) : ""}
 `
@@ -8291,7 +8822,7 @@ async function main() {
   try {
     if (command === "version" || command === "-v") {
       process.stdout.write(
-        "0.1.93\n"
+        "0.1.95\n"
       );
       return;
     }