@distri/core 0.3.4 → 0.3.6

package/dist/index.js

@@ -30,11 +30,13 @@ __export(index_exports, {
   DistriClient: () => DistriClient,
   DistriError: () => DistriError,
   ExternalToolValidationError: () => ExternalToolValidationError,
+  WorkflowRunner: () => WorkflowRunner,
   convertA2AMessageToDistri: () => convertA2AMessageToDistri,
   convertA2APartToDistri: () => convertA2APartToDistri,
   convertA2AStatusUpdateToDistri: () => convertA2AStatusUpdateToDistri,
   convertDistriMessageToA2A: () => convertDistriMessageToA2A,
   convertDistriPartToA2A: () => convertDistriPartToA2A,
+  countSteps: () => countSteps,
   createFailedToolResult: () => createFailedToolResult,
   createSuccessfulToolResult: () => createSuccessfulToolResult,
   decodeA2AStreamEvent: () => decodeA2AStreamEvent,
@@ -47,7 +49,11 @@ __export(index_exports, {
   isDistriMessage: () => isDistriMessage,
   processA2AMessagesData: () => processA2AMessagesData,
   processA2AStreamData: () => processA2AStreamData,
-  uuidv4: () => uuidv4
+  resolveTemplate: () => resolveTemplate,
+  resolveValue: () => resolveValue,
+  stepIcon: () => stepIcon,
+  uuidv4: () => uuidv4,
+  workflowProgress: () => workflowProgress
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1415,6 +1421,27 @@ var _DistriClient = class _DistriClient {
       throw new DistriError(`Failed to fetch agent ${agentId}`, "FETCH_ERROR", error);
     }
   }
+  /**
+   * Fetch all available models grouped by provider, with configuration status.
+   * Each provider includes `configured: boolean` indicating whether the
+   * provider's required API key(s) are set on the server.
+   */
+  async fetchAvailableModels() {
+    try {
+      const response = await this.fetch(`/models`, {
+        headers: {
+          ...this.config.headers
+        }
+      });
+      if (!response.ok) {
+        throw new ApiError(`Failed to fetch models: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError("Failed to fetch available models", "FETCH_ERROR", error);
+    }
+  }
   /**
    * Update an agent's definition (markdown only)
    */
@@ -2053,6 +2080,19 @@ var _DistriClient = class _DistriClient {
    * Enhanced fetch with retry logic and auth headers.
    * Exposed publicly for extensions like DistriHomeClient.
    */
+  /** Call a registered tool via the server's /tools/call endpoint. */
+  async callTool(toolName, input) {
+    const resp = await this.fetch("/tools/call", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tool_name: toolName, input })
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`Tool '${toolName}' failed (${resp.status}): ${text}`);
+    }
+    return resp.json();
+  }
   async fetch(input, initialInit) {
     const url = `${this.config.baseUrl}${input}`;
     return this.fetchAbsolute(url, initialInit);
@@ -2241,7 +2281,7 @@ var Agent = class _Agent {
     const enhancedParams = this.enhanceParamsWithTools(params, tools);
     const a2aStream = this.client.sendMessageStream(this.agentDefinition.id, enhancedParams);
     const self = this;
-    return (async function* () {
+    return async function* () {
       try {
         for await (const event of a2aStream) {
           const converted = decodeA2AStreamEvent(event);
@@ -2274,7 +2314,7 @@ var Agent = class _Agent {
         };
         yield runError;
       }
-    })();
+    }();
   }
   /**
    * Validate that required external tools are registered before invoking.
@@ -2352,10 +2392,9 @@ var Agent = class _Agent {
     }
     return tools;
   }
-  formatExternalToolValidationMessage(requiredTools, missingTools) {
-    const requiredList = requiredTools.join(", ");
+  formatExternalToolValidationMessage(_requiredTools, missingTools) {
     const missingList = missingTools.join(", ");
-    return `Agent has external tools that are not registered: ${missingList}. This is an embedded agent that can run within the parent application. Register DistriWidget for embedding the parent component. Required tools: ${requiredList}.`;
+    return `Agent has external tools that are not registered: ${missingList}.`;
   }
   /**
    * Register multiple hooks at once.
@@ -2399,6 +2438,307 @@ var Agent = class _Agent {
     return agentDefinitions.map((def) => new _Agent(def, client));
   }
 };
+
+// src/workflow.ts
+function countSteps(workflow) {
+  const counts = { pending: 0, blocked: 0, running: 0, done: 0, failed: 0, skipped: 0 };
+  for (const step of workflow.steps) {
+    const status = step.status || "pending";
+    if (status in counts) counts[status]++;
+  }
+  return counts;
+}
+function workflowProgress(workflow) {
+  if (workflow.steps.length === 0) return 100;
+  const done = workflow.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
+  return Math.round(done / workflow.steps.length * 100);
+}
+function stepIcon(status) {
+  switch (status) {
+    case "done":
+      return "\u2705";
+    case "failed":
+      return "\u274C";
+    case "running":
+      return "\u23F3";
+    case "skipped":
+      return "\u23ED";
+    case "blocked":
+      return "\u{1F6AB}";
+    case "pending":
+      return "\u2B1C";
+  }
+}
+
+// src/workflow-runner.ts
+function resolvePath(obj, path) {
+  let current = obj;
+  for (const segment of path.split(".")) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function resolveReference(ref, ctx) {
+  const dotIdx = ref.indexOf(".");
+  if (dotIdx === -1) return void 0;
+  const namespace = ref.substring(0, dotIdx);
+  const path = ref.substring(dotIdx + 1);
+  switch (namespace) {
+    case "input":
+      return resolvePath(ctx.input, path);
+    case "steps":
+      return resolvePath(ctx.steps, path);
+    case "env":
+      return resolvePath(ctx.env, path);
+    case "context":
+      return resolvePath(ctx.input, path) ?? resolvePath(ctx.steps, path) ?? resolvePath(ctx.env, path);
+    default:
+      return void 0;
+  }
+}
+function resolveTemplate(template, ctx) {
+  return template.replace(/\{([^}]+)\}/g, (match, ref) => {
+    const resolved = resolveReference(ref, ctx);
+    if (resolved === void 0) return match;
+    return typeof resolved === "string" ? resolved : JSON.stringify(resolved);
+  });
+}
+function resolveValue(value, ctx) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") && !trimmed.slice(1).includes("{")) {
+      const ref = trimmed.slice(1, -1);
+      const resolved = resolveReference(ref, ctx);
+      if (resolved !== void 0) return resolved;
+    }
+    return resolveTemplate(value, ctx);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => resolveValue(v, ctx));
+  }
+  if (value != null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = resolveValue(v, ctx);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveStepInput(step, ctx) {
+  const mapping = step.input;
+  if (mapping != null) {
+    return resolveValue(mapping, ctx);
+  }
+  return ctx;
+}
+function detectCycles(steps) {
+  const adj = /* @__PURE__ */ new Map();
+  const ids = new Set(steps.map((s) => s.id));
+  for (const step of steps) {
+    const deps = step.depends_on || [];
+    adj.set(step.id, deps);
+    for (const dep of deps) {
+      if (!ids.has(dep)) return `Step '${step.id}' depends on '${dep}' which does not exist`;
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(node, path) {
+    visited.add(node);
+    inStack.add(node);
+    path.push(node);
+    for (const dep of adj.get(node) || []) {
+      if (!visited.has(dep)) {
+        const cycle = dfs(dep, path);
+        if (cycle) return cycle;
+      } else if (inStack.has(dep)) {
+        const cycleStart = path.indexOf(dep);
+        return `Circular dependency: ${path.slice(cycleStart).join(" \u2192 ")} \u2192 ${dep}`;
+      }
+    }
+    inStack.delete(node);
+    path.pop();
+    return null;
+  }
+  for (const step of steps) {
+    if (!visited.has(step.id)) {
+      const cycle = dfs(step.id, []);
+      if (cycle) return cycle;
+    }
+  }
+  return null;
+}
+var WorkflowRunner = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  /** Run a workflow to completion. Returns an async generator of WorkflowEvents. */
+  async *run(definition, input = {}) {
+    const cycle = detectCycles(definition.steps);
+    if (cycle) throw new Error(cycle);
+    const ctx = {
+      input,
+      steps: {},
+      env: this.options.env || {}
+    };
+    const workflow = JSON.parse(JSON.stringify(definition));
+    workflow.status = "running";
+    workflow.context = ctx;
+    for (const step of workflow.steps) {
+      step.status = step.status || "pending";
+      step.depends_on = step.depends_on || [];
+      step.execution = step.execution || "sequential";
+    }
+    yield {
+      event: "workflow_started",
+      workflow_id: workflow.id,
+      workflow_type: workflow.workflow_type,
+      total_steps: workflow.steps.length
+    };
+    while (true) {
+      const runnableIndices = this.findRunnable(workflow);
+      if (runnableIndices.length === 0) break;
+      for (const idx of runnableIndices) {
+        const step = workflow.steps[idx];
+        yield {
+          event: "step_started",
+          workflow_id: workflow.id,
+          step_id: step.id,
+          step_label: step.label
+        };
+        step.status = "running";
+        step.started_at = (/* @__PURE__ */ new Date()).toISOString();
+        try {
+          const resolvedInput = resolveStepInput(step, ctx);
+          const result = this.options.executeStep ? await this.options.executeStep(step, resolvedInput, ctx) : await this.executeStep(step, resolvedInput, ctx);
+          step.status = result.status;
+          step.result = result.result;
+          step.error = result.error ?? null;
+          step.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+          if (result.result != null) {
+            ctx.steps[step.id] = result.result;
+          }
+          if (result.status === "failed") {
+            yield {
+              event: "step_failed",
+              workflow_id: workflow.id,
+              step_id: step.id,
+              step_label: step.label,
+              error: result.error || "Unknown error"
+            };
+            workflow.status = "failed";
+            break;
+          } else {
+            yield {
+              event: "step_completed",
+              workflow_id: workflow.id,
+              step_id: step.id,
+              step_label: step.label,
+              result: result.result
+            };
+          }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          step.status = "failed";
+          step.error = errMsg;
+          step.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+          yield {
+            event: "step_failed",
+            workflow_id: workflow.id,
+            step_id: step.id,
+            step_label: step.label,
+            error: errMsg
+          };
+          workflow.status = "failed";
+          break;
+        }
+      }
+      if (workflow.status === "failed") break;
+    }
+    if (workflow.status !== "failed") {
+      const allDone = workflow.steps.every((s) => s.status === "done" || s.status === "skipped");
+      workflow.status = allDone ? "completed" : "failed";
+    }
+    const stepsDone = workflow.steps.filter((s) => s.status === "done").length;
+    const stepsFailed = workflow.steps.filter((s) => s.status === "failed").length;
+    yield {
+      event: "workflow_completed",
+      workflow_id: workflow.id,
+      status: workflow.status,
+      steps_done: stepsDone,
+      steps_failed: stepsFailed
+    };
+  }
+  /** Find indices of steps that are pending with all dependencies met. */
+  findRunnable(workflow) {
+    const runnable = [];
+    for (let i = 0; i < workflow.steps.length; i++) {
+      const step = workflow.steps[i];
+      if (step.status !== "pending") continue;
+      const depsMet = (step.depends_on || []).every(
+        (depId) => workflow.steps.some((s) => s.id === depId && s.status === "done")
+      );
+      if (depsMet) runnable.push(i);
+    }
+    return runnable;
+  }
+  /** Default step executor — handles tool_call, api_call, checkpoint, etc. */
+  async executeStep(step, resolvedInput, ctx) {
+    switch (step.kind.type) {
+      case "tool_call":
+        return this.executeToolCall(step.kind, resolvedInput);
+      case "api_call":
+        return this.executeApiCall(step, step.kind, ctx);
+      case "checkpoint":
+        return { status: "done", result: { message: step.kind.message } };
+      case "agent_run":
+        return { status: "done", result: { deferred: true, agent_id: step.kind.agent_id, prompt: step.kind.prompt } };
+      case "script":
+        return { status: "done", result: { deferred: true, command: step.kind.command } };
+      case "condition":
+        return { status: "done", result: { expression: step.kind.expression, evaluated: true } };
+      default:
+        return { status: "failed", error: `Unknown step kind: ${step.kind.type}` };
+    }
+  }
+  async executeToolCall(kind, resolvedInput) {
+    try {
+      const result = await this.client.callTool(kind.tool_name, resolvedInput);
+      return { status: "done", result };
+    } catch (err) {
+      return { status: "failed", error: `Tool '${kind.tool_name}' failed: ${err instanceof Error ? err.message : err}` };
+    }
+  }
+  async executeApiCall(step, kind, ctx) {
+    let url = resolveTemplate(kind.url, ctx);
+    let init = {
+      method: kind.method,
+      headers: { "Content-Type": "application/json", ...kind.headers || {} }
+    };
+    if (kind.body) {
+      init.body = JSON.stringify(resolveValue(kind.body, ctx));
+    }
+    if (this.options.buildRequest) {
+      const customized = this.options.buildRequest(step, init, url);
+      url = customized.url;
+      init = customized.init;
+    }
+    try {
+      const resp = await fetch(url, init);
+      const body = await resp.json().catch(() => null);
+      if (resp.ok) {
+        return { status: "done", result: { status: resp.status, body } };
+      } else {
+        return { status: "failed", error: `HTTP ${resp.status} \u2014 ${JSON.stringify(body)}` };
+      }
+    } catch (err) {
+      return { status: "failed", error: `Request failed: ${err instanceof Error ? err.message : err}` };
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   A2AProtocolError,
@@ -2409,11 +2749,13 @@ var Agent = class _Agent {
   DistriClient,
   DistriError,
   ExternalToolValidationError,
+  WorkflowRunner,
   convertA2AMessageToDistri,
   convertA2APartToDistri,
   convertA2AStatusUpdateToDistri,
   convertDistriMessageToA2A,
   convertDistriPartToA2A,
+  countSteps,
   createFailedToolResult,
   createSuccessfulToolResult,
   decodeA2AStreamEvent,
@@ -2426,6 +2768,10 @@ var Agent = class _Agent {
   isDistriMessage,
   processA2AMessagesData,
   processA2AStreamData,
-  uuidv4
+  resolveTemplate,
+  resolveValue,
+  stepIcon,
+  uuidv4,
+  workflowProgress
 });
 //# sourceMappingURL=index.js.map