@moxxy/sdk 0.39.0 → 0.41.0

package/src/provider-utils.test.ts

@@ -59,7 +59,7 @@ describe('zodToJsonSchema', () => {
   it('unwraps ZodOptional / ZodDefault / ZodNullable', () => {
     expect(zodToJsonSchema(z.string().optional())).toEqual({ type: 'string' });
     expect(zodToJsonSchema(z.number().default(0))).toEqual({ type: 'number' });
-    expect(zodToJsonSchema(z.string().nullable())).toEqual({ type: 'string' });
+    expect(zodToJsonSchema(z.string().nullable())).toEqual({ anyOf: [{ type: 'string' }, { type: 'null' }] });
   });
 
   it('converts ZodEnum to string + enum list', () => {

package/src/provider-utils.ts

@@ -122,11 +122,14 @@ function convertSchema(schema: unknown, depth: number): unknown {
     const inner = (def as unknown as { schema: unknown }).schema;
     return zodToJsonSchema(inner, depth + 1);
   }
-  // ZodOptional / ZodNullable / ZodDefault / ZodBranded / ZodReadonly all
+  if (typeName === 'ZodNullable') {
+    const inner = (def as unknown as { innerType: unknown }).innerType;
+    return { anyOf: [zodToJsonSchema(inner, depth + 1), { type: 'null' }] };
+  }
+  // ZodOptional / ZodDefault / ZodBranded / ZodReadonly all
   // wrap an inner schema we want to unwrap for JSON-schema purposes.
   if (
     typeName === 'ZodOptional' ||
-    typeName === 'ZodNullable' ||
     typeName === 'ZodDefault' ||
     typeName === 'ZodBranded' ||
     typeName === 'ZodReadonly'
@@ -176,8 +179,30 @@ function convertSchema(schema: unknown, depth: number): unknown {
     }
     return { type: 'object', properties, required };
   }
-  if (typeName === 'ZodString') return { type: 'string' };
-  if (typeName === 'ZodNumber') return { type: 'number' };
+  if (typeName === 'ZodString' || typeName === 'ZodNumber') {
+    const checks = (def as unknown as { checks: ReadonlyArray<{ kind: string; value?: number; inclusive?: boolean; regex?: RegExp }> }).checks;
+    const result: Record<string, unknown> = { type: typeName === 'ZodString' ? 'string' : 'number' };
+    const bound = (key: string, value: number, lower: boolean) => {
+      const previous = result[key];
+      result[key] = typeof previous === 'number' ? (lower ? Math.max(previous, value) : Math.min(previous, value)) : value;
+    };
+    for (const check of checks) {
+      if (check.kind === 'int') result.type = 'integer';
+      if (typeName === 'ZodString' && check.regex && !check.regex.flags) {
+        // JSON Schema has no JS RegExp flags. Never misrepresent a flagged regex.
+        if (result.pattern === undefined) result.pattern = check.regex.source;
+      }
+      if (check.value === undefined) continue;
+      if (typeName === 'ZodString') {
+        if (check.kind === 'min' || check.kind === 'length') bound('minLength', check.value, true);
+        if (check.kind === 'max' || check.kind === 'length') bound('maxLength', check.value, false);
+      } else {
+        if (check.kind === 'min') bound(check.inclusive ? 'minimum' : 'exclusiveMinimum', check.value, true);
+        if (check.kind === 'max') bound(check.inclusive ? 'maximum' : 'exclusiveMaximum', check.value, false);
+      }
+    }
+    return result;
+  }
   if (typeName === 'ZodBoolean') return { type: 'boolean' };
   if (typeName === 'ZodEnum') {
     const values = (def as unknown as { values: ReadonlyArray<string> }).values;
@@ -202,7 +227,10 @@ function convertSchema(schema: unknown, depth: number): unknown {
   if (typeName === 'ZodArray') {
     // ZodArray._def.type is the element schema.
     const items = zodToJsonSchema((def as unknown as { type: unknown }).type, depth + 1);
-    return { type: 'array', items };
+    const limits = def as unknown as { minLength: { value: number } | null; maxLength: { value: number } | null; exactLength: { value: number } | null };
+    const minimum = limits.exactLength ?? limits.minLength;
+    const maximum = limits.exactLength ?? limits.maxLength;
+    return { type: 'array', items, ...(minimum ? { minItems: minimum.value } : {}), ...(maximum ? { maxItems: maximum.value } : {}) };
   }
   if (typeName === 'ZodRecord') {
     // `z.record(keyType, valueType)` — an open-ended object whose values share

package/src/session-like.ts

@@ -9,6 +9,7 @@ import type { PluginSetupSpec } from './schemas.js';
 import type { ToolIcon } from './tool-icon.js';
 import type { ToolCompactPresentation } from './tool.js';
 import type { ClientChromeItem } from './client-chrome.js';
+import type { ComputerControlService } from './computer-control.js';
 
 /**
  * Options accepted by `SessionLike.runTurn`. Defined here (rather than in
@@ -237,7 +238,7 @@ export interface WorkflowRunView {
    * with `runId`). Optional for back-compat — absent from older hosts that
    * never paused. A run/resume that completes or fails reports those.
    */
-  readonly status?: 'completed' | 'paused' | 'failed';
+  readonly status?: 'completed' | 'paused' | 'failed' | 'cancelled';
   /** Set when `status` is `paused` — pass to {@link WorkflowsView.resume}. */
   readonly runId?: string;
 }
@@ -267,6 +268,8 @@ export interface WorkflowSaveView {
  * stay capability-detectable — a channel must feature-check before calling.
  */
 export interface WorkflowsView {
+  delete?(name: string): Promise<void>;
+  readonly approvals?: import('./workflow-approval.js').WorkflowApprovalsView;
   list(): Promise<ReadonlyArray<WorkflowSummaryView>>;
   setEnabled(name: string, enabled: boolean): Promise<void>;
   run(name: string): Promise<WorkflowRunView>;
@@ -522,6 +525,8 @@ export interface SessionLike {
   mcpAdmin?: McpAdminView;
   /** Provider admin slice — edit stored (runtime-registered) providers. */
   providerAdmin?: ProviderAdminView;
+  /** Optional human control of the session's native Computer Use turns. */
+  computerControl?: ComputerControlService;
   /** Workflows slice backing the `/workflows` modal. */
   workflows?: WorkflowsView;
   /** Plugin-management slice backing the `/plugins` picker. */

package/src/tool-dispatch.ts

@@ -8,6 +8,10 @@ import type { ToolCallVerdict } from './hooks.js';
 import type { CollectedToolUse } from './mode/collect-stream.js';
 import type { StuckLoopDetector, StuckSignal } from './mode/stuck-loop.js';
 
+export type ToolDispatchContext = Pick<ModeContext,
+  'sessionId' | 'turnId' | 'cwd' | 'env' | 'services' | 'log' | 'hooks' |
+  'permissions' | 'tools' | 'signal' | 'subagents' | 'emit'>;
+
 /**
  * Execute a single tool-use end-to-end: dispatch `dispatchToolCall` hooks, run
  * the permission check, invoke the tool, and emit the approved/denied/result
@@ -23,7 +27,7 @@ import type { StuckLoopDetector, StuckSignal } from './mode/stuck-loop.js';
  * then rejects on the next turn.
  */
 export async function* dispatchToolCall(
-  ctx: ModeContext,
+  ctx: ToolDispatchContext,
   t: CollectedToolUse,
   iteration: number,
 ): AsyncGenerator<MoxxyEvent, void, unknown> {
@@ -56,12 +60,32 @@ export async function* dispatchToolCall(
 
     const decision = await ctx.permissions.check(
       { callId: asToolCallId(t.id), name: t.name, input: actualInput },
-      { sessionId: String(ctx.sessionId), toolDescription: ctx.tools.get(t.name)?.description },
+      { sessionId: String(ctx.sessionId), turnId: String(ctx.turnId), toolDescription: ctx.tools.get(t.name)?.description },
     );
     if (decision.mode === 'deny') {
       yield* emitDenied(ctx, t, decision.reason ?? 'denied by resolver', 'resolver');
       return;
     }
+    // A deferred approval may outlive its turn, or policy may change while
+    // the operator is deciding. Neither permits a late side effect.
+    ctx.signal.throwIfAborted();
+    const mandatory = await ctx.permissions.mandatoryCheck?.(
+      { callId: asToolCallId(t.id), name: t.name, input: actualInput },
+      { sessionId: String(ctx.sessionId), turnId: String(ctx.turnId) },
+    );
+    if (mandatory?.mode === 'deny') {
+      yield* emitDenied(ctx, t, mandatory.reason ?? 'workflow approval denied', 'resolver');
+      return;
+    }
+    const policy = await ctx.permissions.policyCheck?.(
+      { callId: asToolCallId(t.id), name: t.name, input: actualInput },
+      { sessionId: String(ctx.sessionId), turnId: String(ctx.turnId) },
+    );
+    if (policy?.mode === 'deny') {
+      yield* emitDenied(ctx, t, policy.reason ?? 'denied by policy', 'policy');
+      return;
+    }
+    ctx.signal.throwIfAborted();
     yield await ctx.emit({
       type: 'tool_call_approved',
       sessionId: ctx.sessionId,
@@ -129,7 +153,7 @@ function hookDeny(verdict: ToolCallVerdict): string | null {
 }
 
 async function* emitDenied(
-  ctx: ModeContext,
+  ctx: ToolDispatchContext,
   t: CollectedToolUse,
   reason: string,
   by: 'hook' | 'resolver' | 'policy',

package/src/tool.ts

@@ -16,6 +16,13 @@ import type { ToolIsolationSpec } from './isolation.js';
  */
 export type HostedTool = { readonly type: 'web_search' };
 
+/** Image pixels and optional model-facing context (for example capture geometry). */
+export interface ToolImageResult {
+  readonly mediaType: string;
+  readonly base64: string;
+  readonly forModel?: string;
+}
+
 /**
  * Capability-mediated filesystem operations injected by isolators that
  * support brokering. Handlers can opt in by checking `ctx.fs` at runtime

package/src/workflow-approval.test.ts

@@ -0,0 +1,12 @@
+import { expect, it } from 'vitest';
+import { workflowApprovalItemsSchema } from './workflow-approval.js';
+
+it('validates approval results at remote boundaries without changing the displayed scope', () => {
+  const item = { id: '07a3ed71-ebc0-458f-acb0-9db5a5636632', workflowId: 'workflow', workflowName: 'Test',
+    revision: 'revision', runId: 'run', tool: 'Write', input: { path: 'test.txt' }, createdAt: 100, status: 'pending' };
+  expect(workflowApprovalItemsSchema.parse([item])).toEqual([item]);
+  expect(() => workflowApprovalItemsSchema.parse([{ ...item, status: 'approved-by-default' }])).toThrow();
+  expect(() => workflowApprovalItemsSchema.parse([{ ...item, id: '../another' }])).toThrow();
+  expect(() => workflowApprovalItemsSchema.parse([{ ...item, createdAt: 0 }])).toThrow();
+  expect(() => workflowApprovalItemsSchema.parse([{ ...item, admin: true }])).toThrow();
+});

package/src/workflow-approval.ts

@@ -0,0 +1,41 @@
+export interface WorkflowApprovalScope {
+  readonly workflowId: string;
+  readonly workflowName: string;
+  readonly revision: string;
+  readonly runId: string;
+}
+
+export type WorkflowApprovalChoice = 'allow_once' | 'allow_always' | 'deny';
+export interface WorkflowApprovalItem extends WorkflowApprovalScope {
+  readonly id: string;
+  readonly tool: string;
+  readonly input: unknown;
+  readonly createdAt: number;
+  readonly status: 'pending' | 'allowed' | 'denied' | 'cancelled' | 'interrupted' | 'revoked';
+  readonly choice?: WorkflowApprovalChoice;
+}
+
+export interface WorkflowApprovalsView {
+  list(): Promise<ReadonlyArray<WorkflowApprovalItem>>;
+  decide(id: string, choice: WorkflowApprovalChoice): Promise<void>;
+  revoke(id: string): Promise<void>;
+  cancel(id: string): Promise<void>;
+}
+import { z } from 'zod';
+
+export const workflowApprovalItemSchema = z
+  .object({
+    id: z.string().uuid(),
+    workflowId: z.string().min(1),
+    workflowName: z.string().min(1),
+    revision: z.string().min(1),
+    runId: z.string().min(1),
+    tool: z.string().min(1),
+    input: z.unknown(),
+    createdAt: z.number().finite().positive(),
+    status: z.enum(['pending', 'allowed', 'denied', 'cancelled', 'interrupted', 'revoked']),
+    choice: z.enum(['allow_once', 'allow_always', 'deny']).optional(),
+  })
+  .strict()
+  .transform((item) => ({ ...item, input: item.input }));
+export const workflowApprovalItemsSchema = z.array(workflowApprovalItemSchema);

package/src/workflow.ts

@@ -198,11 +198,13 @@ export type WorkflowEventSubtype =
   | 'workflow_step_completed'
   | 'workflow_step_skipped'
   | 'workflow_step_failed'
+  | 'workflow_step_cancelled'
   | 'workflow_step_awaiting_input'
   | 'workflow_paused'
   | 'workflow_resumed'
   | 'workflow_completed'
-  | 'workflow_failed';
+  | 'workflow_failed'
+  | 'workflow_cancelled';
 
 /**
  * Everything an executor needs to run a workflow, supplied by the caller.
@@ -231,9 +233,9 @@ export interface WorkflowRunDeps {
   readonly depth?: number;
 }
 
-export type WorkflowStepStatus = 'completed' | 'skipped' | 'failed' | 'awaiting_input';
+export type WorkflowStepStatus = 'completed' | 'skipped' | 'failed' | 'awaiting_input' | 'cancelled';
 
-export type WorkflowRunStatus = 'completed' | 'paused' | 'failed';
+export type WorkflowRunStatus = 'completed' | 'paused' | 'failed' | 'cancelled';
 
 export interface WorkflowStepResult {
   readonly id: string;