robotrock 0.7.0 → 0.8.0

package/dist/chunk-55JHCNYX.js

@@ -1,613 +0,0 @@
-import {
-  RobotRockError,
-  createClient,
-  resolveRobotRockConfig
-} from "./chunk-ZG2XVK6Y.js";
-import {
-  assignToSchema,
-  threadUpdateStatusSchema
-} from "./chunk-ZHASQUX6.js";
-
-// src/ai/context.ts
-var APPROVE_BY_HUMAN_ACTIONS = [
-  { id: "approve", title: "Approve" },
-  { id: "decline", title: "Decline" }
-];
-function isRobotRockClient(value) {
-  return typeof value === "object" && value !== null && "sendToHuman" in value && typeof value.sendToHuman === "function";
-}
-function normalizeRobotRockAiContext(clientOrContext) {
-  if (isRobotRockClient(clientOrContext)) {
-    return { mode: "polling", client: clientOrContext };
-  }
-  if (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow") {
-    return clientOrContext;
-  }
-  if (clientOrContext.mode === "polling" || clientOrContext.mode === void 0) {
-    if (!("client" in clientOrContext) || !clientOrContext.client) {
-      throw new Error("RobotRock AI polling mode requires `client` on the context object.");
-    }
-    return { mode: "polling", client: clientOrContext.client };
-  }
-  throw new Error(`Unknown RobotRock AI mode: ${String(clientOrContext.mode)}`);
-}
-async function sendToHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
-    const { sendToHumanTask } = await import("./trigger/index.js");
-    const waitResult = await sendToHumanTask.triggerAndWait({
-      ...payload,
-      ...context.app ? { app: context.app } : {}
-    });
-    if (!waitResult.ok) {
-      throw waitResult.error;
-    }
-    return waitResult.output;
-  }
-  if (context.mode === "workflow") {
-    const { sendToHumanInWorkflow } = await import("./workflow/index.js");
-    const result2 = await sendToHumanInWorkflow({
-      ...payload,
-      ...context.app ? { app: context.app } : {}
-    });
-    return result2;
-  }
-  const result = await context.client.sendToHuman(payload);
-  if (result.mode !== "handled") {
-    throw new Error(
-      "RobotRock task was created but not handled. Configure client polling or webhook, or use mode: 'trigger' / 'workflow' for durable waits."
-    );
-  }
-  return {
-    actionId: result.actionId,
-    data: result.data,
-    handledBy: result.handledBy,
-    handledAt: result.handledAt,
-    taskId: result.taskId
-  };
-}
-async function sendUpdateForAi(context, payload) {
-  if (context.mode === "workflow") {
-    const { sendUpdateInWorkflow } = await import("./workflow/index.js");
-    return sendUpdateInWorkflow({
-      ...payload,
-      ...context.app ? { app: context.app } : {}
-    });
-  }
-  if (context.mode === "trigger") {
-    const client = createClient(
-      resolveRobotRockConfig(context.app ? { app: context.app } : void 0)
-    );
-    return client.sendUpdate(payload);
-  }
-  return context.client.sendUpdate(payload);
-}
-async function approveByHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
-    const { approveByHumanTask } = await import("./trigger/index.js");
-    const waitResult = await approveByHumanTask.triggerAndWait({
-      ...payload,
-      ...context.app ? { app: context.app } : {}
-    });
-    if (!waitResult.ok) {
-      throw waitResult.error;
-    }
-    return waitResult.output;
-  }
-  if (context.mode === "workflow") {
-    const { approveByHumanInWorkflow } = await import("./workflow/index.js");
-    return await approveByHumanInWorkflow({
-      ...payload,
-      ...context.app ? { app: context.app } : {}
-    });
-  }
-  const result = await context.client.sendToHuman({
-    ...payload,
-    actions: APPROVE_BY_HUMAN_ACTIONS
-  });
-  if (result.mode !== "handled") {
-    throw new Error(
-      "RobotRock approval was not handled. Configure client polling or use mode: 'trigger' / 'workflow' for durable waits."
-    );
-  }
-  return {
-    actionId: result.actionId,
-    data: result.data,
-    handledBy: result.handledBy,
-    handledAt: result.handledAt,
-    taskId: result.taskId
-  };
-}
-
-// src/ai/human-tool-result.ts
-var APPROVE_IDS = /* @__PURE__ */ new Set(["approve", "approved"]);
-var DECLINE_IDS = /* @__PURE__ */ new Set(["decline", "reject", "deny", "denied"]);
-function toHumanToolResult(result) {
-  const payload = {
-    taskId: result.taskId,
-    actionId: result.actionId,
-    data: result.data,
-    handledBy: result.handledBy,
-    handledAt: result.handledAt.toISOString()
-  };
-  if (APPROVE_IDS.has(result.actionId)) {
-    payload.approved = true;
-  } else if (DECLINE_IDS.has(result.actionId)) {
-    payload.approved = false;
-  }
-  return payload;
-}
-
-// src/ai/approve-by-human-tool.ts
-import { tool } from "ai";
-import { z } from "zod";
-var APPROVE_BY_HUMAN_ACTIONS2 = [
-  { id: "approve", title: "Approve" },
-  { id: "decline", title: "Decline" }
-];
-var approveByHumanInputSchema = z.object({
-  type: z.string().optional().describe("Task type slug; defaults to ai-approval"),
-  name: z.string().describe("Short title for the approval request"),
-  description: z.string().describe("What needs approval and the consequences of approving or declining"),
-  contextSummary: z.string().optional().describe("Optional markdown summary shown to the reviewer")
-});
-function approveByHumanTool(clientOrContext, maybeOptions = {}) {
-  const isDurable = typeof clientOrContext === "object" && clientOrContext !== null && "mode" in clientOrContext && (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow");
-  const aiContext = normalizeRobotRockAiContext(
-    isDurable ? {
-      mode: clientOrContext.mode,
-      app: clientOrContext.app
-    } : clientOrContext
-  );
-  const options = isDurable ? clientOrContext : maybeOptions;
-  const description = options.description ?? "Request explicit human approval before a sensitive or irreversible step. Returns whether the human approved or declined.";
-  return tool({
-    description,
-    inputSchema: approveByHumanInputSchema,
-    execute: async (input) => {
-      const taskContext = input.contextSummary !== void 0 ? {
-        data: { summary: input.contextSummary },
-        ui: {
-          summary: { "ui:widget": "textarea", "ui:options": { rows: 6 } }
-        }
-      } : void 0;
-      const result = await approveByHumanForAi(aiContext, {
-        type: input.type ?? options.defaultType ?? "ai-approval",
-        name: input.name,
-        description: input.description,
-        context: taskContext
-      });
-      return toHumanToolResult(result);
-    }
-  });
-}
-
-// src/ai/create-send-to-human-tool.ts
-import { tool as tool2 } from "ai";
-import { z as z2 } from "zod";
-var contextInputSchema = z2.object({
-  data: z2.record(z2.unknown()).optional(),
-  ui: z2.record(z2.unknown()).optional()
-}).optional();
-var sendToHumanToolInputSchema = z2.object({
-  type: z2.string().describe("Task type slug shown in the RobotRock inbox"),
-  name: z2.string().describe("Short title for the human reviewer"),
-  description: z2.string().optional().describe("What you need from the human and why you cannot proceed alone"),
-  context: contextInputSchema.describe("Optional structured context for the inbox UI"),
-  validUntil: z2.string().datetime().optional().describe("Optional ISO deadline for the task"),
-  assignTo: assignToSchema.optional().describe(
-    "Assign to tenant member emails and/or group slugs; narrows who sees the task in the inbox"
-  )
-});
-function createSendToHumanTool(clientOrOptions, maybeOptions) {
-  const isDurable = typeof clientOrOptions === "object" && clientOrOptions !== null && "mode" in clientOrOptions && (clientOrOptions.mode === "trigger" || clientOrOptions.mode === "workflow");
-  const aiContext = normalizeRobotRockAiContext(
-    isDurable ? {
-      mode: clientOrOptions.mode,
-      app: clientOrOptions.app
-    } : clientOrOptions
-  );
-  const options = isDurable ? clientOrOptions : maybeOptions;
-  const description = options.description ?? "Request structured input or a decision from a human in the RobotRock inbox. Use when you lack required information, need policy approval, or must confirm an irreversible step.";
-  return tool2({
-    description,
-    inputSchema: sendToHumanToolInputSchema,
-    execute: async (input) => {
-      const taskContext = input.context ? {
-        data: input.context.data ?? {},
-        ui: input.context.ui
-      } : void 0;
-      const payload = {
-        type: input.type ?? options.defaultType ?? "ai-human-input",
-        name: input.name,
-        description: input.description,
-        context: taskContext,
-        validUntil: input.validUntil,
-        assignTo: input.assignTo,
-        actions: options.actions,
-        ...options.threadId ? { threadId: options.threadId } : {}
-      };
-      const result = await sendToHumanForAi(aiContext, payload);
-      return toHumanToolResult(result);
-    }
-  });
-}
-
-// src/ai/create-send-update-tool.ts
-import { tool as tool3 } from "ai";
-import { z as z3 } from "zod";
-var sendUpdateToolInputSchema = z3.object({
-  threadId: z3.string().optional().describe(
-    "Thread to post the update to. Use the `threadId` returned by a prior send-to-human task. Omit only when a session threadId is configured on the tool."
-  ),
-  message: z3.string().describe("Short progress update (1-2 sentences) shown in the inbox status bar"),
-  status: threadUpdateStatusSchema.optional().describe(
-    "Lifecycle status driving the status-bar icon/color: info, queued, running, waiting, succeeded, failed, cancelled"
-  )
-});
-function createSendUpdateTool(clientOrOptions, maybeOptions = {}) {
-  const isDurable = typeof clientOrOptions === "object" && clientOrOptions !== null && "mode" in clientOrOptions && (clientOrOptions.mode === "trigger" || clientOrOptions.mode === "workflow");
-  const aiContext = normalizeRobotRockAiContext(
-    isDurable ? {
-      mode: clientOrOptions.mode,
-      app: clientOrOptions.app
-    } : clientOrOptions
-  );
-  const options = isDurable ? clientOrOptions : maybeOptions;
-  const description = options.description ?? "Post a short progress update to the RobotRock thread you are working on. Use to report status changes (running, succeeded, failed) so humans can follow along in the inbox.";
-  return tool3({
-    description,
-    inputSchema: sendUpdateToolInputSchema,
-    execute: async (input) => {
-      const threadId = input.threadId ?? options.threadId;
-      if (!threadId) {
-        throw new Error(
-          "createSendUpdateTool: no threadId. Pass `threadId` from a prior send-to-human result, or configure a session `threadId` in the tool options."
-        );
-      }
-      try {
-        const update = await sendUpdateForAi(aiContext, {
-          threadId,
-          message: input.message,
-          status: input.status
-        });
-        return { posted: true, threadId, update };
-      } catch (error) {
-        if (error instanceof RobotRockError && error.statusCode === 404) {
-          return {
-            posted: false,
-            threadId,
-            reason: "thread_not_found",
-            message: `No task exists for thread "${threadId}" yet, so the update was not posted. Create a task on this thread with send-to-human before reporting progress.`
-          };
-        }
-        throw error;
-      }
-    }
-  });
-}
-
-// src/ai/create-ai-tools.ts
-function createRobotRockAiTools(options) {
-  const mode = options.mode ?? (options.client ? "polling" : "trigger");
-  if (mode === "polling" && !options.client) {
-    throw new Error("createRobotRockAiTools: polling mode requires `client`.");
-  }
-  const context = mode === "trigger" ? { mode: "trigger", app: options.app } : mode === "workflow" ? { mode: "workflow", app: options.app } : { mode: "polling", client: options.client };
-  const durableContext = context.mode === "trigger" || context.mode === "workflow" ? context : null;
-  const pollingClient = context.mode === "polling" ? context.client : void 0;
-  return {
-    context,
-    approveByHuman: (toolOptions) => durableContext ? approveByHumanTool({ ...durableContext, ...toolOptions }) : approveByHumanTool(pollingClient, toolOptions),
-    sendToHuman: (toolOptions) => durableContext ? createSendToHumanTool({
-      ...durableContext,
-      ...options.threadId ? { threadId: options.threadId } : {},
-      ...toolOptions
-    }) : createSendToHumanTool(pollingClient, {
-      ...options.threadId ? { threadId: options.threadId } : {},
-      ...toolOptions
-    }),
-    sendUpdate: (toolOptions = {}) => durableContext ? createSendUpdateTool({
-      ...durableContext,
-      ...options.threadId ? { threadId: options.threadId } : {},
-      ...toolOptions
-    }) : createSendUpdateTool(pollingClient, {
-      ...options.threadId ? { threadId: options.threadId } : {},
-      ...toolOptions
-    })
-  };
-}
-function createRobotRockAiTriggerContext(options = {}) {
-  return { mode: "trigger", ...options };
-}
-function createRobotRockAiWorkflowContext(options = {}) {
-  return { mode: "workflow", ...options };
-}
-
-// src/ai/format-tool-approval-task.ts
-var DEFAULT_APPROVE_ACTIONS = [
-  { id: "approve", title: "Approve execution" },
-  { id: "deny", title: "Deny" }
-];
-function defaultFormatToolApprovalTask(toolCall, options = {}) {
-  const approveId = options.approveActionId ?? "approve";
-  const denyId = options.denyActionId ?? "deny";
-  let inputPreview;
-  try {
-    inputPreview = JSON.stringify(toolCall.input, null, 2);
-  } catch {
-    inputPreview = String(toolCall.input);
-  }
-  return {
-    type: options.type ?? "ai-tool-approval",
-    name: `Approve: ${toolCall.toolName}`,
-    description: `Review the proposed \`${toolCall.toolName}\` tool call before it runs.`,
-    context: {
-      data: {
-        toolName: toolCall.toolName,
-        toolCallId: toolCall.toolCallId,
-        input: toolCall.input
-      },
-      ui: {
-        toolName: { "ui:widget": "text" },
-        toolCallId: { "ui:widget": "text" },
-        input: { "ui:widget": "textarea" }
-      }
-    },
-    actions: [
-      { id: approveId, title: "Approve execution" },
-      { id: denyId, title: "Deny" }
-    ]
-  };
-}
-
-// src/ai/tool-approval-bridge.ts
-function buildToolMatcher(config) {
-  const names = config.tools ? new Set(config.tools) : null;
-  return (toolCall) => {
-    if (config.when?.(toolCall)) {
-      return true;
-    }
-    if (names && names.has(toolCall.toolName)) {
-      return true;
-    }
-    return false;
-  };
-}
-function createRobotRockToolApproval(config) {
-  const matches = buildToolMatcher(config);
-  const toolApproval = async (options) => {
-    return matches(options.toolCall) ? "user-approval" : void 0;
-  };
-  return toolApproval;
-}
-function createRobotRockNeedsApproval(config) {
-  const matches = buildToolMatcher(config);
-  return async (_input, options) => {
-    const toolCall = findToolCallInMessages(options.messages, options.toolCallId);
-    if (!toolCall) {
-      return false;
-    }
-    return matches(toolCall);
-  };
-}
-function applyRobotRockToolApprovalToTools(tools, config) {
-  const names = config.tools ? new Set(config.tools) : null;
-  const needsApproval = createRobotRockNeedsApproval(config);
-  const next = { ...tools };
-  for (const key of Object.keys(tools)) {
-    const name = String(key);
-    const shouldApply = names && names.has(name) || names === null && config.when !== void 0;
-    if (!shouldApply) {
-      continue;
-    }
-    const existing = tools[key];
-    next[key] = {
-      ...existing,
-      needsApproval
-    };
-  }
-  return next;
-}
-function findToolCallInMessages(messages, toolCallId) {
-  if (!messages) {
-    return void 0;
-  }
-  for (const message of messages) {
-    if (typeof message !== "object" || message === null) {
-      continue;
-    }
-    const role = message.role;
-    if (role !== "assistant") {
-      continue;
-    }
-    const content = message.content;
-    if (!Array.isArray(content)) {
-      continue;
-    }
-    for (const part of content) {
-      if (typeof part !== "object" || part === null) {
-        continue;
-      }
-      const p = part;
-      if (p.type === "tool-call" && p.toolCallId === toolCallId) {
-        return {
-          toolName: String(p.toolName ?? ""),
-          toolCallId,
-          input: p.input
-        };
-      }
-    }
-  }
-  return void 0;
-}
-function collectApprovalRequests(source) {
-  const requests = [];
-  const visit = (value) => {
-    if (!value) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        visit(item);
-      }
-      return;
-    }
-    if (typeof value !== "object") {
-      return;
-    }
-    const obj = value;
-    if (obj.type === "tool-approval-request" && typeof obj.approvalId === "string") {
-      if (obj.isAutomatic === true) {
-        return;
-      }
-      const embedded = obj.toolCall;
-      const toolCallId = typeof obj.toolCallId === "string" ? obj.toolCallId : typeof embedded?.toolCallId === "string" ? embedded.toolCallId : void 0;
-      let toolCall;
-      if (embedded && typeof embedded.toolName === "string") {
-        toolCall = {
-          toolName: embedded.toolName,
-          toolCallId: String(embedded.toolCallId ?? toolCallId ?? ""),
-          input: embedded.input
-        };
-      } else if (toolCallId) {
-        toolCall = findToolCallInMessages(
-          source.messages,
-          toolCallId
-        );
-      }
-      requests.push({
-        type: "tool-approval-request",
-        approvalId: obj.approvalId,
-        toolCallId,
-        toolCall,
-        isAutomatic: obj.isAutomatic === true
-      });
-      return;
-    }
-    if (Array.isArray(obj.content)) {
-      visit(obj.content);
-    }
-    if (Array.isArray(obj.steps)) {
-      visit(obj.steps);
-    }
-    if (obj.response && typeof obj.response === "object") {
-      visit(obj.response.messages);
-    }
-  };
-  visit(source);
-  if (typeof source === "object" && source !== null && Array.isArray(source.content)) {
-    visit(source.content);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return requests.filter((r) => {
-    if (seen.has(r.approvalId)) {
-      return false;
-    }
-    seen.add(r.approvalId);
-    return true;
-  });
-}
-function resolveToolCallForRequest(request, source, messages) {
-  if (request.toolCall) {
-    return request.toolCall;
-  }
-  const toolCallId = request.toolCallId;
-  if (toolCallId) {
-    const fromMessages = findToolCallInMessages(messages, toolCallId);
-    if (fromMessages) {
-      return fromMessages;
-    }
-  }
-  if (typeof source === "object" && source !== null && Array.isArray(source.toolCalls)) {
-    for (const call of source.toolCalls) {
-      if (call.toolCallId === toolCallId) {
-        return {
-          toolName: String(call.toolName ?? ""),
-          toolCallId: String(call.toolCallId ?? ""),
-          input: call.input
-        };
-      }
-    }
-  }
-  throw new Error(
-    `Could not resolve tool call for approval ${request.approvalId}. Pass messages that include the assistant tool-call.`
-  );
-}
-async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options = {}) {
-  const context = normalizeRobotRockAiContext(clientOrContext);
-  const approveId = options.approveActionId ?? "approve";
-  const denyId = options.denyActionId ?? "deny";
-  const formatTask = options.formatTask ?? defaultFormatToolApprovalTask;
-  const baseMessages = typeof source === "object" && source !== null && Array.isArray(source.messages) ? [...source.messages] : [];
-  const requests = collectApprovalRequests(source);
-  const responses = [];
-  for (const request of requests) {
-    const toolCall = resolveToolCallForRequest(request, source, baseMessages);
-    const taskInput = formatTask(toolCall, {
-      approveActionId: approveId,
-      denyActionId: denyId
-    });
-    const result = await sendToHumanForAi(context, taskInput);
-    const approved = result.actionId === approveId;
-    const reason = typeof result.data === "object" && result.data !== null && "reason" in result.data && typeof result.data.reason === "string" ? result.data.reason : approved ? "Approved in RobotRock inbox" : "Denied in RobotRock inbox";
-    responses.push({
-      type: "tool-approval-response",
-      approvalId: request.approvalId,
-      approved,
-      reason
-    });
-  }
-  const messages = [...baseMessages];
-  if (responses.length > 0) {
-    messages.push({ role: "tool", content: responses });
-  }
-  return { responses, messages };
-}
-async function runWithRobotRockApprovals(options) {
-  const clientOrContext = options.context ?? (options.client ? options.client : (() => {
-    throw new Error("runWithRobotRockApprovals requires `client` or `context`.");
-  })());
-  const maxRounds = options.maxRounds ?? 20;
-  let messages = options.messages ? [...options.messages] : [];
-  let lastResult;
-  for (let round = 0; round < maxRounds; round++) {
-    lastResult = await options.generate(messages);
-    const { responses, messages: nextMessages } = await resolveToolApprovalsViaRobotRock(
-      clientOrContext,
-      { ...lastResult, messages },
-      options.resolveOptions
-    );
-    if (responses.length === 0) {
-      return lastResult;
-    }
-    messages = nextMessages;
-  }
-  throw new Error(`RobotRock approval loop exceeded maxRounds (${maxRounds})`);
-}
-
-export {
-  normalizeRobotRockAiContext,
-  sendToHumanForAi,
-  sendUpdateForAi,
-  approveByHumanForAi,
-  toHumanToolResult,
-  APPROVE_BY_HUMAN_ACTIONS2 as APPROVE_BY_HUMAN_ACTIONS,
-  approveByHumanInputSchema,
-  approveByHumanTool,
-  sendToHumanToolInputSchema,
-  createSendToHumanTool,
-  sendUpdateToolInputSchema,
-  createSendUpdateTool,
-  createRobotRockAiTools,
-  createRobotRockAiTriggerContext,
-  createRobotRockAiWorkflowContext,
-  DEFAULT_APPROVE_ACTIONS,
-  defaultFormatToolApprovalTask,
-  createRobotRockToolApproval,
-  createRobotRockNeedsApproval,
-  applyRobotRockToolApprovalToTools,
-  collectApprovalRequests,
-  resolveToolApprovalsViaRobotRock,
-  runWithRobotRockApprovals
-};
-//# sourceMappingURL=chunk-55JHCNYX.js.map