@mindstudio-ai/agent 0.1.93 → 0.1.95

package/dist/index.js

@@ -3581,7 +3581,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.",
@@ -3601,7 +3602,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;
     }
@@ -3617,7 +3620,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);
@@ -3737,6 +3744,397 @@ async function runTaskStream(httpConfig, body, onEvent) {
   return result;
 }
 
+// src/task/local.ts
+var DEFAULT_MAX_TURNS = 20;
+var MAX_TURNS_LIMIT = 100;
+var MAX_TOOL_OUTPUT_CHARS = 5e4;
+var MAX_TURN_ATTEMPTS = 5;
+var INITIAL_BACKOFF_MS = 1e3;
+var STALL_TIMEOUT_MS = 3e5;
+var TURN_UNAVAILABLE_CODE = "task_turn_unavailable";
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+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;
+}
+var TurnError = class extends Error {
+  constructor(message, retryable, phase, status, errorCode) {
+    super(message);
+    this.retryable = retryable;
+    this.phase = phase;
+    this.status = status;
+    this.errorCode = errorCode;
+  }
+};
+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)
+  );
+}
+
 // src/generated/steps.ts
 function applyStepMethods(AgentClass) {
   const proto = AgentClass.prototype;
@@ -4382,8 +4780,8 @@ var MindStudioAgent = class {
       ...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)
     });
@@ -4469,8 +4867,8 @@ var MindStudioAgent = class {
       ...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)
     };
@@ -4772,11 +5170,135 @@ var MindStudioAgent = class {
    * ```
    */
   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.
@@ -5983,6 +6505,7 @@ var session = new Proxy(
   }
 );
 var stream = (data) => mindstudio.stream(data);
+var waitUntil = (promise) => mindstudio.waitUntil(promise);
 var resolveUser = (userId) => mindstudio.resolveUser(userId);
 var reportIssue = (input) => mindstudio.reportIssue(input);
 var prerender = {
@@ -6009,6 +6532,7 @@ export {
   session,
   stepMetadata,
   stream,
-  voice
+  voice,
+  waitUntil
 };
 //# sourceMappingURL=index.js.map