@tangle-network/agent-interface 0.45.0 → 0.46.1

package/dist/profile-diff.js

@@ -179,24 +179,24 @@ function removeResources(resources, removal) {
     const next = { ...resources };
     if (removal.files !== undefined) {
         if (removal.files === true) {
-            next.files = undefined;
+            delete next.files;
         }
         else {
             const removeSet = new Set(removal.files);
-            next.files = next.files?.filter((file) => {
+            setOrDelete(next, "files", next.files?.filter((file) => {
                 const name = resourceName(file.resource);
                 return !removeSet.has(file.path) && !(name && removeSet.has(name));
-            });
+            }));
         }
     }
-    next.tools = removeResourceRefs(next.tools, removal.tools);
-    next.skills = removeResourceRefs(next.skills, removal.skills);
-    next.agents = removeResourceRefs(next.agents, removal.agents);
-    next.commands = removeResourceRefs(next.commands, removal.commands);
+    setOrDelete(next, "tools", removeResourceRefs(next.tools, removal.tools));
+    setOrDelete(next, "skills", removeResourceRefs(next.skills, removal.skills));
+    setOrDelete(next, "agents", removeResourceRefs(next.agents, removal.agents));
+    setOrDelete(next, "commands", removeResourceRefs(next.commands, removal.commands));
     if (removal.instructions)
-        next.instructions = undefined;
+        delete next.instructions;
     if (removal.failOnError)
-        next.failOnError = undefined;
+        delete next.failOnError;
     for (const key of [
         "files",
         "tools",
@@ -205,81 +205,91 @@ function removeResources(resources, removal) {
         "commands",
     ]) {
         if (next[key]?.length === 0)
-            next[key] = undefined;
+            delete next[key];
     }
-    return Object.values(next).some((value) => value !== undefined)
-        ? next
-        : undefined;
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+/**
+ * Write a resolved optional value, or drop the key when the value is gone.
+ *
+ * Removal deletes the key instead of blanking it: profile identity is an RFC
+ * 8785 digest over own keys, so a key left behind holding `undefined` either
+ * changes that digest or is refused by the canonical JSON domain.
+ */
+function setOrDelete(target, key, value) {
+    if (value === undefined) {
+        delete target[key];
+        return;
+    }
+    target[key] = value;
 }
 function applyRemoval(profile, remove) {
     if (!remove)
         return profile;
     const next = { ...profile };
     if (remove.identity) {
-        next.name = undefined;
-        next.description = undefined;
-        next.version = undefined;
+        delete next.name;
+        delete next.description;
+        delete next.version;
     }
     if (remove.tags !== undefined) {
-        next.tags = removeValues(asMutable(next.tags), remove.tags);
+        setOrDelete(next, "tags", removeValues(asMutable(next.tags), remove.tags));
     }
     if (remove.prompt === true) {
-        next.prompt = undefined;
+        delete next.prompt;
     }
     else if (remove.prompt && next.prompt) {
         const prompt = { ...next.prompt };
         if (remove.prompt.systemPrompt)
-            prompt.systemPrompt = undefined;
+            delete prompt.systemPrompt;
         if (remove.prompt.appendSystemPrompt)
-            prompt.appendSystemPrompt = undefined;
-        prompt.instructions = removeValues(prompt.instructions, remove.prompt.instructions);
-        next.prompt = Object.values(prompt).some((value) => value !== undefined)
-            ? prompt
-            : undefined;
+            delete prompt.appendSystemPrompt;
+        setOrDelete(prompt, "instructions", removeValues(prompt.instructions, remove.prompt.instructions));
+        setOrDelete(next, "prompt", Object.keys(prompt).length > 0 ? prompt : undefined);
     }
     if (remove.model !== undefined) {
-        next.model = removeKeys(next.model, remove.model);
+        setOrDelete(next, "model", removeKeys(next.model, remove.model));
     }
     if (remove.harness !== undefined)
-        next.harness = undefined;
+        delete next.harness;
     if (remove.permissions !== undefined) {
-        next.permissions = removeKeys(next.permissions, remove.permissions);
+        setOrDelete(next, "permissions", removeKeys(next.permissions, remove.permissions));
     }
     if (remove.tools !== undefined) {
-        next.tools = removeKeys(next.tools, remove.tools);
+        setOrDelete(next, "tools", removeKeys(next.tools, remove.tools));
     }
     if (remove.mcp !== undefined) {
-        next.mcp = removeKeys(next.mcp, remove.mcp);
+        setOrDelete(next, "mcp", removeKeys(next.mcp, remove.mcp));
     }
     if (remove.subagents !== undefined) {
-        next.subagents = removeKeys(next.subagents, remove.subagents);
+        setOrDelete(next, "subagents", removeKeys(next.subagents, remove.subagents));
     }
     if (remove.resources !== undefined) {
-        next.resources = removeResources(next.resources, remove.resources);
+        setOrDelete(next, "resources", removeResources(next.resources, remove.resources));
     }
     if (remove.hooks !== undefined) {
-        next.hooks = removeKeys(next.hooks, remove.hooks);
+        setOrDelete(next, "hooks", removeKeys(next.hooks, remove.hooks));
     }
     if (remove.modes !== undefined) {
-        next.modes = removeKeys(next.modes, remove.modes);
+        setOrDelete(next, "modes", removeKeys(next.modes, remove.modes));
     }
     if (remove.confidential)
-        next.confidential = undefined;
+        delete next.confidential;
     if (remove.metadata !== undefined) {
-        next.metadata = removeKeys(next.metadata, remove.metadata);
+        setOrDelete(next, "metadata", removeKeys(next.metadata, remove.metadata));
     }
     if (remove.extensions !== undefined) {
-        next.extensions = removeKeys(next.extensions, remove.extensions);
+        setOrDelete(next, "extensions", removeKeys(next.extensions, remove.extensions));
     }
     if (next.connections && remove.connections !== undefined) {
         if (remove.connections === true) {
-            next.connections = undefined;
+            delete next.connections;
         }
         else {
             const removeSet = new Set(remove.connections);
             const filtered = next.connections.filter((connection) => !removeSet.has(connection.connectionId) &&
                 !(connection.alias && removeSet.has(connection.alias)));
-            next.connections = filtered.length > 0 ? filtered : undefined;
+            setOrDelete(next, "connections", filtered.length > 0 ? filtered : undefined);
         }
     }
     return next;
@@ -347,13 +357,12 @@ export function pruneAgentProfileDiff(diff, axesToRemove) {
         if (remove)
             delete remove[axis];
     }
-    return {
-        ...diff,
-        ...(set && Object.values(set).some((value) => value !== undefined)
-            ? { set }
-            : { set: undefined }),
-        ...(remove && Object.values(remove).some((value) => value !== undefined)
-            ? { remove }
-            : { remove: undefined }),
-    };
+    const pruned = { ...diff };
+    setOrDelete(pruned, "set", set && Object.values(set).some((value) => value !== undefined)
+        ? set
+        : undefined);
+    setOrDelete(pruned, "remove", remove && Object.values(remove).some((value) => value !== undefined)
+        ? remove
+        : undefined);
+    return pruned;
 }

package/dist/provider-adapter.d.ts

@@ -0,0 +1,45 @@
+import type { InteractionAcknowledgement, InteractionResponse, InteractionResponseCommand } from "./interaction.js";
+import type { AgentExecutionInput, AgentExecutionResult } from "./execution-types.js";
+import type { BackendMessage, GetMessagesOptions } from "./backend-message.js";
+import type { SdkHostServices } from "./host-services.js";
+import type { BackendCapabilities, ProviderConfig } from "./provider-config.js";
+import type { BackendArtifact, BackendListOptions, McpConfig, McpStatusResponse } from "./mcp.js";
+import type { StreamEvent } from "./stream-events.js";
+export interface SdkProviderAdapter {
+    readonly provider: string;
+    getCapabilities(): BackendCapabilities;
+    initialize(config: ProviderConfig): Promise<void>;
+    createSession?(options?: {
+        workspaceRoot?: string;
+    }): Promise<string>;
+    forkSession?(options: {
+        sessionId: string;
+        messageId?: string;
+        workspaceRoot?: string;
+    }): Promise<string>;
+    execute(input: AgentExecutionInput, services: SdkHostServices, onEvent?: (event: StreamEvent) => void): Promise<AgentExecutionResult>;
+    shutdown(): Promise<void>;
+    healthCheck(): Promise<boolean>;
+    getMessages?(options: GetMessagesOptions): Promise<BackendMessage[]>;
+    addMcp?(name: string, config: McpConfig): Promise<void>;
+    getMcpStatus?(): Promise<McpStatusResponse>;
+    ensureMcps?(required: Record<string, McpConfig>): Promise<void>;
+    updateConfig?(config: unknown): Promise<unknown>;
+    getAccount?(): Promise<unknown>;
+    listModels?(): Promise<unknown>;
+    listRepositories?(): Promise<unknown>;
+    listAgents?(options?: BackendListOptions): Promise<unknown>;
+    getAgent?(agentId: string): Promise<unknown>;
+    archiveAgent?(agentId: string): Promise<void>;
+    unarchiveAgent?(agentId: string): Promise<void>;
+    deleteAgent?(agentId: string): Promise<void>;
+    listRuns?(agentId: string, options?: BackendListOptions): Promise<unknown>;
+    getRun?(runId: string, agentId?: string): Promise<unknown>;
+    listAgentMessages?(agentId: string, options?: BackendListOptions): Promise<unknown>;
+    listArtifacts?(sessionId: string): Promise<BackendArtifact[]>;
+    downloadArtifact?(sessionId: string, path: string): Promise<Uint8Array>;
+    respondToInteraction?(response: InteractionResponse): Promise<void>;
+    respondToInteractionCommand?(command: InteractionResponseCommand, options?: {
+        signal?: AbortSignal;
+    }): Promise<InteractionAcknowledgement>;
+}

package/dist/provider-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/provider-config.d.ts

@@ -0,0 +1,58 @@
+export type BackendCapabilities = {
+    streaming: boolean;
+    toolUse: boolean;
+    reasoning: boolean;
+    multimodal: boolean;
+    contextWindow: number;
+    interactions?: string[];
+};
+export type ProviderCapabilities = {
+    supportsVision: boolean;
+    supportsLogprobs: boolean;
+    supportsToolCalls: boolean;
+    supportsComputerUse: boolean;
+};
+export type CliAuthFile = {
+    path: string;
+    content: string;
+    mode?: number;
+};
+export type ProviderConfig = {
+    model: {
+        provider?: string;
+        model?: string;
+        apiKey?: string;
+        baseUrl?: string;
+        maxThinkingTokens?: number;
+        mode?: "api" | "cli";
+        authMode?: "api-key" | "oauth";
+        authFiles?: CliAuthFile[];
+    };
+    server?: {
+        port?: number;
+        hostname?: string;
+    };
+    workspace?: {
+        rootPath: string;
+    };
+    metadata?: Record<string, unknown>;
+    profile?: Record<string, unknown>;
+};
+export type ModelGatewayDefaults = {
+    provider: string;
+    name: string;
+    rootUrl: string;
+    baseUrl: string;
+    model: string;
+    apiKeyEnvVar: string;
+};
+export declare const TANGLE_ROUTER_DEFAULT_ROOT_URL = "https://router.tangle.tools";
+export declare const TANGLE_ROUTER_DEFAULT_MODEL = "zai/glm-4.7";
+export declare function normalizeOpenAiCompatibleBaseUrl(baseUrl: string): string;
+export declare function resolveTangleRouterDefaults(env?: Record<string, string | undefined>): ModelGatewayDefaults;
+export declare function withModelGatewayDefaults<T extends ProviderConfig["model"]>(model: T, defaults?: ModelGatewayDefaults): T;
+export type NativeWebToolPosture = {
+    search?: boolean;
+    fetch?: boolean;
+};
+export declare function resolveNativeWebTools(tools: Record<string, boolean> | undefined): NativeWebToolPosture;

package/dist/provider-config.js

@@ -0,0 +1,42 @@
+export const TANGLE_ROUTER_DEFAULT_ROOT_URL = "https://router.tangle.tools";
+export const TANGLE_ROUTER_DEFAULT_MODEL = "zai/glm-4.7";
+export function normalizeOpenAiCompatibleBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, "");
+    return /\/v\d+$/.test(trimmed) ? trimmed : `${trimmed}/v1`;
+}
+export function resolveTangleRouterDefaults(env = process.env) {
+    const rootUrl = env.TANGLE_ROUTER_URL || TANGLE_ROUTER_DEFAULT_ROOT_URL;
+    return {
+        provider: "openai-compat",
+        name: env.TANGLE_ROUTER_PROVIDER_NAME || "Tangle Router",
+        rootUrl,
+        baseUrl: normalizeOpenAiCompatibleBaseUrl(env.TANGLE_ROUTER_BASE_URL || rootUrl),
+        model: env.TANGLE_ROUTER_MODEL || TANGLE_ROUTER_DEFAULT_MODEL,
+        apiKeyEnvVar: env.TANGLE_ROUTER_API_KEY_ENV || "OPENCODE_MODEL_API_KEY",
+    };
+}
+export function withModelGatewayDefaults(model, defaults = resolveTangleRouterDefaults()) {
+    return {
+        ...model,
+        provider: model.provider || defaults.provider,
+        model: model.model || defaults.model,
+        baseUrl: model.baseUrl || defaults.baseUrl,
+    };
+}
+const nativeWebSearchKeys = new Set(["websearch"]);
+const nativeWebFetchKeys = new Set(["webfetch", "fetch"]);
+export function resolveNativeWebTools(tools) {
+    if (!tools)
+        return {};
+    const posture = {};
+    for (const [key, value] of Object.entries(tools)) {
+        if (typeof value !== "boolean")
+            continue;
+        const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+        if (nativeWebSearchKeys.has(normalized))
+            posture.search = value;
+        else if (nativeWebFetchKeys.has(normalized))
+            posture.fetch = value;
+    }
+    return posture;
+}

package/dist/runtime-control.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { StreamEvent } from "./index.js";
+import type { StreamEvent } from "./stream-events.js";
 import type { Sha256Digest } from "./agent-candidate.js";
 /** Provider-neutral coordinates sufficient to recreate control of one run. */
 export interface AgentRunControlRef {
@@ -19,10 +19,24 @@ export declare const AgentRunControlRefSchema: z.ZodObject<{
     executionId: z.ZodOptional<z.ZodString>;
     requestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;
+/** Coordinates that are complete enough for a retryable state-changing action. */
+export interface AgentExactRunControlRef extends AgentRunControlRef {
+    sessionId: string;
+    executionId: string;
+    requestDigest: Sha256Digest;
+}
+export declare const AgentExactRunControlRefSchema: z.ZodObject<{
+    runId: z.ZodString;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    executionId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
 export type AgentRunCancellationEffect = "cancel_requested" | "cancelled" | "not_live" | "unknown";
 export interface AgentRunCancellationRequestMaterial {
     operationId: string;
-    run: AgentRunControlRef;
+    run: AgentExactRunControlRef;
     reason?: string;
 }
 export interface AgentRunCancellationRequest extends AgentRunCancellationRequestMaterial {
@@ -30,26 +44,27 @@ export interface AgentRunCancellationRequest extends AgentRunCancellationRequest
 }
 export declare function agentRunCancellationRequestDigest(request: AgentRunCancellationRequestMaterial): Sha256Digest;
 export declare const AgentRunCancellationRequestSchema: z.ZodObject<{
-    operationId: z.ZodString;
     requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    operationId: z.ZodString;
     run: z.ZodObject<{
         runId: z.ZodString;
         provider: z.ZodString;
         environmentId: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        executionId: z.ZodOptional<z.ZodString>;
-        requestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export interface AgentRunCancellationAcknowledgement {
     operationId: string;
     requestDigest: Sha256Digest;
-    run: AgentRunControlRef;
+    run: AgentExactRunControlRef;
     status: "accepted" | "replayed" | "conflict" | "unknown";
     effect: AgentRunCancellationEffect;
     message?: string;
     retryable?: boolean;
+    existingRequestDigest?: Sha256Digest;
 }
 export declare const AgentRunCancellationAcknowledgementSchema: z.ZodObject<{
     operationId: z.ZodString;
@@ -58,9 +73,9 @@ export declare const AgentRunCancellationAcknowledgementSchema: z.ZodObject<{
         runId: z.ZodString;
         provider: z.ZodString;
         environmentId: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        executionId: z.ZodOptional<z.ZodString>;
-        requestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     status: z.ZodEnum<{
         unknown: "unknown";
@@ -76,8 +91,70 @@ export declare const AgentRunCancellationAcknowledgementSchema: z.ZodObject<{
     }>;
     message: z.ZodOptional<z.ZodString>;
     retryable: z.ZodOptional<z.ZodBoolean>;
+    existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;
 export declare function agentRunCancellationAcknowledgementMatchesRequest(request: AgentRunCancellationRequest, acknowledgement: AgentRunCancellationAcknowledgement): boolean;
+export type AgentRunControlAction = "steer" | "cancel" | "status" | "reconnect";
+export interface AgentRunControlRequestMaterial {
+    operationId: string;
+    action: AgentRunControlAction;
+    run: AgentExactRunControlRef;
+    payload?: Record<string, unknown>;
+}
+export interface AgentRunControlRequest extends AgentRunControlRequestMaterial {
+    requestDigest: Sha256Digest;
+}
+export declare function agentRunControlRequestDigest(request: AgentRunControlRequestMaterial): Sha256Digest;
+export declare const AgentRunControlRequestSchema: z.ZodObject<{
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    operationId: z.ZodString;
+    action: z.ZodEnum<{
+        status: "status";
+        steer: "steer";
+        cancel: "cancel";
+        reconnect: "reconnect";
+    }>;
+    run: z.ZodObject<{
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    payload: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
+export interface AgentRunControlAcknowledgement {
+    operationId: string;
+    requestDigest: Sha256Digest;
+    run: AgentExactRunControlRef;
+    status: "accepted" | "replayed" | "conflict" | "unknown";
+    message?: string;
+    retryable?: boolean;
+    existingRequestDigest?: Sha256Digest;
+}
+export declare const AgentRunControlAcknowledgementSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    run: z.ZodObject<{
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        conflict: "conflict";
+        accepted: "accepted";
+        replayed: "replayed";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+}, z.core.$strict>;
+export declare function agentRunControlAcknowledgementMatchesRequest(request: AgentRunControlRequest, acknowledgement: AgentRunControlAcknowledgement): boolean;
 /** Runtime validator for every member of the existing canonical event union. */
 export declare const CanonicalStreamEventSchema: z.ZodType<StreamEvent>;
 /** Ordered, replayable envelope around the existing canonical event union. */