@anvia/studio 0.2.0 → 0.2.2

package/dist/index.js

@@ -51,11 +51,7 @@ var StudioRunTraceObserver = class {
             startedAt,
             input: toJsonValue(args.request),
             output: toJsonValue(endArgs.response),
-            metadata: {
-              model: args.request.model ?? "default",
-              toolCount: args.request.tools.length,
-              ...endArgs.firstDeltaMs === void 0 ? {} : { firstDeltaMs: endArgs.firstDeltaMs }
-            }
+            metadata: generationMetadata(args, endArgs)
           })
         );
       },
@@ -69,10 +65,7 @@ var StudioRunTraceObserver = class {
             startedAt,
             input: toJsonValue(args.request),
             error: serializeError(errorArgs.error),
-            metadata: {
-              model: args.request.model ?? "default",
-              toolCount: args.request.tools.length
-            }
+            metadata: generationMetadata(args)
           })
         );
       }
@@ -94,7 +87,7 @@ var StudioRunTraceObserver = class {
           startedAt,
           input: parseOrString(args.args),
           output: parseOrString(endArgs.result),
-          metadata: toolMetadata(args, endArgs.skipped)
+          metadata: toolMetadata(args, endArgs.skipped, endArgs.result)
         });
         this.observations.push(parentObservation);
         this.observations.push(...childTrace.observations(parentObservation.id));
@@ -372,13 +365,134 @@ function traceMetadata(args, messages) {
     messages
   });
 }
-function toolMetadata(args, skipped) {
+function generationMetadata(args, endArgs) {
+  const request = args.request;
+  const response = endArgs?.response;
+  const rawResponse = isRecord(response?.rawResponse) ? response.rawResponse : void 0;
+  const effectiveModel = request.model ?? stringValue(rawResponse?.model) ?? args.modelInfo?.defaultModel ?? "default";
+  const providerResponse = providerResponseSummary(rawResponse);
+  const usage = response?.usage;
+  return compactJsonObject({
+    provider: args.modelInfo?.provider,
+    model: effectiveModel,
+    requestedModel: request.model,
+    defaultModel: args.modelInfo?.defaultModel,
+    messageId: response?.messageId,
+    usage,
+    toolCount: request.tools.length,
+    toolNames: request.tools.map((tool) => tool.name),
+    documentCount: request.documents.length,
+    historyCount: request.chatHistory.length,
+    temperature: request.temperature,
+    maxTokens: request.maxTokens,
+    toolChoice: request.toolChoice,
+    additionalParamKeys: isRecord(request.additionalParams) ? Object.keys(request.additionalParams).sort() : void 0,
+    hasOutputSchema: request.outputSchema !== void 0,
+    firstDeltaMs: endArgs?.firstDeltaMs,
+    providerResponse,
+    modelInfo: compactJsonObject({
+      provider: args.modelInfo?.provider,
+      model: effectiveModel,
+      requestedModel: request.model,
+      defaultModel: args.modelInfo?.defaultModel,
+      capabilities: args.modelInfo?.capabilities
+    }),
+    modelCall: compactJsonObject({
+      request: completionRequestSummary(request),
+      providerRequest: args.providerRequest
+    }),
+    response: compactJsonObject({
+      messageId: response?.messageId,
+      usage,
+      contentTypes: response?.choice.map((item) => item.type),
+      providerResponse
+    }),
+    tools: compactJsonObject({
+      count: request.tools.length,
+      names: request.tools.map((tool) => tool.name),
+      toolChoice: request.toolChoice,
+      hasOutputSchema: request.outputSchema !== void 0
+    }),
+    timing: compactJsonObject({
+      firstDeltaMs: endArgs?.firstDeltaMs
+    })
+  });
+}
+function completionRequestSummary(request) {
+  return compactJsonObject({
+    model: request.model,
+    instructions: request.instructions === void 0 ? void 0 : { present: true },
+    messageCount: request.chatHistory.length,
+    documentCount: request.documents.length,
+    documentIds: request.documents.map((document) => document.id),
+    toolCount: request.tools.length,
+    toolNames: request.tools.map((tool) => tool.name),
+    temperature: request.temperature,
+    maxTokens: request.maxTokens,
+    toolChoice: request.toolChoice,
+    additionalParamKeys: isRecord(request.additionalParams) ? Object.keys(request.additionalParams).sort() : void 0,
+    hasOutputSchema: request.outputSchema !== void 0
+  });
+}
+function providerResponseSummary(rawResponse) {
+  if (rawResponse === void 0) {
+    return void 0;
+  }
+  const reasoning = isRecord(rawResponse.reasoning) ? rawResponse.reasoning : void 0;
+  const text = isRecord(rawResponse.text) ? rawResponse.text : void 0;
+  const toolUsage = isRecord(rawResponse.tool_usage) ? rawResponse.tool_usage : void 0;
+  const webSearch = isRecord(toolUsage?.web_search) ? toolUsage.web_search : void 0;
+  const summary = compactJsonObject({
+    id: rawResponse.id,
+    status: rawResponse.status,
+    serviceTier: rawResponse.service_tier,
+    store: rawResponse.store,
+    parallelToolCalls: rawResponse.parallel_tool_calls,
+    promptCacheKey: rawResponse.prompt_cache_key,
+    promptCacheRetention: rawResponse.prompt_cache_retention,
+    reasoningEffort: reasoning?.effort,
+    textVerbosity: text?.verbosity,
+    webSearchRequestCount: webSearch?.num_requests
+  });
+  return Object.keys(summary).length === 0 ? void 0 : summary;
+}
+function toolMetadata(args, skipped, result) {
+  const schema = isRecord(args.toolDefinition?.parameters) ? args.toolDefinition.parameters : {};
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
   return compactJsonObject({
     internalCallId: args.internalCallId,
     toolCallId: args.toolCallId,
-    skipped
+    skipped,
+    argumentBytes: byteLength(args.args),
+    resultBytes: result === void 0 ? void 0 : byteLength(result),
+    hasCallSignature: args.toolCall.signature !== void 0,
+    hasAdditionalParams: args.toolCall.additionalParams !== void 0,
+    toolDescription: args.toolDefinition?.description,
+    parameterKeys: Object.keys(properties).sort(),
+    requiredParameterKeys: required,
+    approvalRequired: args.toolMetadata?.approvalRequired,
+    mcpServerName: args.toolMetadata?.mcpServerName,
+    tools: compactJsonObject({
+      name: args.toolName,
+      internalCallId: args.internalCallId,
+      toolCallId: args.toolCallId,
+      skipped,
+      description: args.toolDefinition?.description,
+      parameterKeys: Object.keys(properties).sort(),
+      requiredParameterKeys: required,
+      approvalRequired: args.toolMetadata?.approvalRequired,
+      mcpServerName: args.toolMetadata?.mcpServerName,
+      argumentBytes: byteLength(args.args),
+      resultBytes: result === void 0 ? void 0 : byteLength(result),
+      hasCallSignature: args.toolCall.signature !== void 0,
+      hasAdditionalParams: args.toolCall.additionalParams !== void 0
+    })
   });
 }
+function byteLength(value) {
+  return new TextEncoder().encode(value).length;
+}
 function compactJsonObject(values) {
   const entries = Object.entries(values).flatMap(
     ([key, value]) => value === void 0 ? [] : [[key, toJsonValue(value)]]
@@ -473,6 +587,8 @@ function registerStudioUi(app, options) {
   app.get(`${options.path}/sessions`, async (c) => c.html(await renderShell()));
   app.get(`${options.path}/agents`, async (c) => c.html(await renderShell()));
   app.get(`${options.path}/knowledge`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/knowledge/:tab`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/knowledge/*`, async (c) => c.html(await renderShell()));
   if (options.rootRoutes) {
     app.get("/playground", async (c) => c.html(await renderRootShell()));
     app.get("/playground/:sessionId", async (c) => c.html(await renderRootShell()));
@@ -1056,6 +1172,82 @@ var SqliteSessionStore = class {
     });
     return rows.map(toPipelineLog);
   }
+  savePipelineRun(input) {
+    const db = this.database();
+    db.prepare(
+      `INSERT INTO runner_pipeline_runs (
+        run_id,
+        pipeline_id,
+        status,
+        input_json,
+        output_json,
+        error_json,
+        metadata_json,
+        started_at,
+        ended_at,
+        duration_ms
+      ) VALUES (
+        $runId,
+        $pipelineId,
+        $status,
+        $input,
+        $output,
+        $error,
+        $metadata,
+        $startedAt,
+        $endedAt,
+        $durationMs
+      )
+      ON CONFLICT(run_id) DO UPDATE SET
+        pipeline_id = excluded.pipeline_id,
+        status = excluded.status,
+        input_json = excluded.input_json,
+        output_json = excluded.output_json,
+        error_json = excluded.error_json,
+        metadata_json = excluded.metadata_json,
+        started_at = excluded.started_at,
+        ended_at = excluded.ended_at,
+        duration_ms = excluded.duration_ms`
+    ).run({
+      $runId: input.runId,
+      $pipelineId: input.pipelineId,
+      $status: input.status,
+      $input: JSON.stringify(input.input),
+      $output: input.output === void 0 ? null : JSON.stringify(input.output),
+      $error: input.error === void 0 ? null : JSON.stringify(input.error),
+      $metadata: input.metadata === void 0 ? null : JSON.stringify(input.metadata),
+      $startedAt: input.startedAt,
+      $endedAt: input.endedAt ?? null,
+      $durationMs: input.durationMs ?? null
+    });
+    return {
+      runId: input.runId,
+      pipelineId: input.pipelineId,
+      status: input.status,
+      input: input.input,
+      ...input.output === void 0 ? {} : { output: input.output },
+      ...input.error === void 0 ? {} : { error: input.error },
+      ...input.metadata === void 0 ? {} : { metadata: input.metadata },
+      startedAt: input.startedAt,
+      ...input.endedAt === void 0 ? {} : { endedAt: input.endedAt },
+      ...input.durationMs === void 0 ? {} : { durationMs: input.durationMs }
+    };
+  }
+  listPipelineRuns(options) {
+    const db = this.database();
+    const rows = db.prepare(
+      `SELECT run_id, pipeline_id, status, input_json, output_json, error_json,
+                metadata_json, started_at, ended_at, duration_ms
+         FROM runner_pipeline_runs
+         WHERE pipeline_id = $pipelineId
+         ORDER BY started_at DESC
+         LIMIT $limit`
+    ).all({
+      $pipelineId: options.pipelineId,
+      $limit: options.limit
+    });
+    return rows.map(toPipelineRun);
+  }
   deleteSession(id) {
     const db = this.database();
     try {
@@ -1290,6 +1482,20 @@ var SqliteSessionStore = class {
       ) STRICT;
       CREATE INDEX IF NOT EXISTS runner_pipeline_logs_pipeline_sequence_idx
         ON runner_pipeline_logs(pipeline_id, sequence ASC);
+      CREATE TABLE IF NOT EXISTS runner_pipeline_runs (
+        run_id TEXT PRIMARY KEY,
+        pipeline_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        input_json TEXT NOT NULL,
+        output_json TEXT,
+        error_json TEXT,
+        metadata_json TEXT,
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        duration_ms INTEGER
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_pipeline_runs_pipeline_started_idx
+        ON runner_pipeline_runs(pipeline_id, started_at DESC);
       CREATE TABLE IF NOT EXISTS runner_traces (
         id TEXT PRIMARY KEY,
         session_id TEXT NOT NULL,
@@ -1479,6 +1685,23 @@ function toPipelineLog(row) {
     ...metadata === void 0 ? {} : { metadata }
   };
 }
+function toPipelineRun(row) {
+  const output = parseJsonValue(row.output_json);
+  const error = parseJsonValue(row.error_json);
+  const metadata = parseJsonValue(row.metadata_json);
+  return {
+    runId: row.run_id,
+    pipelineId: row.pipeline_id,
+    status: row.status,
+    input: JSON.parse(row.input_json),
+    ...output === void 0 ? {} : { output },
+    ...error === void 0 ? {} : { error },
+    ...metadata === void 0 ? {} : { metadata },
+    startedAt: row.started_at,
+    ...row.ended_at === null ? {} : { endedAt: row.ended_at },
+    ...row.duration_ms === null ? {} : { durationMs: row.duration_ms }
+  };
+}
 function messageParts(message) {
   if (message.role === "system") {
     return [{ type: "text", value: { type: "text", text: message.content } }];
@@ -1709,10 +1932,12 @@ function resolveStores(options) {
   const sessions = resolveSessionStore(options, defaultStore);
   const traces = resolveTraceStore(options, sessions, defaultStore);
   const pipelineLogs = resolvePipelineLogStore(options, sessions, defaultStore);
+  const pipelineRuns = resolvePipelineRunStore(options, sessions, pipelineLogs, defaultStore);
   return {
     ...sessions === void 0 ? {} : { sessions },
     ...traces === void 0 ? {} : { traces },
-    ...pipelineLogs === void 0 ? {} : { pipelineLogs }
+    ...pipelineLogs === void 0 ? {} : { pipelineLogs },
+    ...pipelineRuns === void 0 ? {} : { pipelineRuns }
   };
 }
 function resolveSessionStore(options, defaultStore) {
@@ -1748,6 +1973,21 @@ function resolvePipelineLogStore(options, sessionStore, defaultStore) {
   }
   return defaultStore;
 }
+function resolvePipelineRunStore(options, sessionStore, pipelineLogStore, defaultStore) {
+  if (options.stores?.pipelineRuns === false) {
+    return void 0;
+  }
+  if (options.stores?.pipelineRuns !== void 0) {
+    return options.stores.pipelineRuns;
+  }
+  if (sessionStore !== void 0 && isPipelineRunStore(sessionStore)) {
+    return sessionStore;
+  }
+  if (pipelineLogStore !== void 0 && isPipelineRunStore(pipelineLogStore)) {
+    return pipelineLogStore;
+  }
+  return defaultStore;
+}
 function isTraceStore(store) {
   const candidate = store;
   return typeof candidate.listSessionTraces === "function" && typeof candidate.getTrace === "function" && typeof candidate.saveTrace === "function";
@@ -1756,6 +1996,10 @@ function isPipelineLogStore(store) {
   const candidate = store;
   return typeof candidate.appendPipelineLog === "function" && typeof candidate.listPipelineLogs === "function";
 }
+function isPipelineRunStore(store) {
+  const candidate = store;
+  return typeof candidate.savePipelineRun === "function" && typeof candidate.listPipelineRuns === "function";
+}
 function unsupportedCapabilities(stores) {
   return [
     ...stores.sessions === void 0 ? ["sessions"] : [],
@@ -2254,22 +2498,41 @@ function registerKnowledgeRoutes(app, props) {
       return errorResponse(c, 400, "bad_request", "Invalid limit");
     }
     const summary = {
-      agents: props.agents.map(agentKnowledgeConfig),
+      agents: await Promise.all(props.agents.map(agentKnowledgeConfig)),
       evidence: await recentKnowledgeEvidence(props.traceStore, limit)
     };
     return c.json(summary);
   });
+  app.get("/knowledge/items", async (c) => {
+    const limit = parseLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "Invalid limit");
+    }
+    const agentId = optionalQueryString(c.req.query("agentId"));
+    const sourceId = optionalQueryString(c.req.query("sourceId"));
+    if (agentId === void 0 || sourceId === void 0) {
+      return errorResponse(c, 400, "bad_request", "agentId and sourceId are required");
+    }
+    const agent = props.agents.find((item) => item.id === agentId);
+    if (agent === void 0) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    const page = await knowledgeItemsPage(agent, sourceId, {
+      limit,
+      cursor: optionalQueryString(c.req.query("cursor"))
+    });
+    if (page === void 0) {
+      return errorResponse(c, 404, "not_found", "Knowledge source not found");
+    }
+    return c.json(page);
+  });
 }
-function agentKnowledgeConfig(agent) {
+async function agentKnowledgeConfig(agent) {
   const agentName = agent.name ?? agent.agent.name;
   return {
     agentId: agent.id,
     ...agentName === void 0 ? {} : { agentName },
-    sources: [
-      { kind: "static_context", count: agent.agent.staticContext.length },
-      { kind: "dynamic_context", count: agent.agent.dynamicContexts.length },
-      { kind: "dynamic_tools", count: agent.agent.dynamicTools.length }
-    ],
+    sources: await knowledgeSources(agent),
     staticContext: agent.agent.staticContext.map((document) => ({
       id: document.id,
       text: document.text,
@@ -2277,6 +2540,199 @@ function agentKnowledgeConfig(agent) {
     }))
   };
 }
+async function knowledgeSources(agent) {
+  const sources = [
+    {
+      sourceId: staticSourceId(),
+      kind: "static_context",
+      label: "Static context",
+      count: agent.agent.staticContext.length,
+      inspectable: true,
+      itemCount: agent.agent.staticContext.length
+    }
+  ];
+  const dynamicContextSources = await Promise.all(
+    agent.agent.dynamicContexts.map(async (registration, index) => {
+      const inspect = inspectFn(registration.index);
+      const count = await inspectableCount(inspect, registration.options.filter);
+      return {
+        sourceId: dynamicContextSourceId(index),
+        kind: "dynamic_context",
+        label: `Dynamic context ${index + 1}`,
+        count: 1,
+        registrationIndex: index,
+        topK: registration.options.topK,
+        ...registration.options.threshold === void 0 ? {} : { threshold: registration.options.threshold },
+        inspectable: inspect !== void 0,
+        ...count === void 0 ? {} : { itemCount: count }
+      };
+    })
+  );
+  const dynamicToolSources = await Promise.all(
+    agent.agent.dynamicTools.map(async (registration, index) => {
+      const inspect = inspectFn(registration.index);
+      const count = await inspectableCount(inspect, registration.options.filter);
+      return {
+        sourceId: dynamicToolsSourceId(index),
+        kind: "dynamic_tools",
+        label: `Dynamic tools ${index + 1}`,
+        count: 1,
+        registrationIndex: index,
+        topK: registration.options.topK,
+        ...registration.options.threshold === void 0 ? {} : { threshold: registration.options.threshold },
+        inspectable: inspect !== void 0,
+        ...count === void 0 ? {} : { itemCount: count }
+      };
+    })
+  );
+  return [...sources, ...dynamicContextSources, ...dynamicToolSources];
+}
+async function inspectableCount(inspect, filter) {
+  if (inspect === void 0) {
+    return void 0;
+  }
+  const page = await inspect({ limit: 1, filter });
+  return page.totalCount;
+}
+async function knowledgeItemsPage(agent, sourceId, request) {
+  if (sourceId === staticSourceId()) {
+    return staticKnowledgeItemsPage(agent, request);
+  }
+  const dynamicContextIndex = dynamicSourceIndex(sourceId, "dynamic_context");
+  if (dynamicContextIndex !== void 0) {
+    const registration = agent.agent.dynamicContexts[dynamicContextIndex];
+    if (registration === void 0) {
+      return void 0;
+    }
+    const inspect = inspectFn(registration.index);
+    if (inspect === void 0) {
+      return nonInspectablePage(agent.id, sourceId, "dynamic_context");
+    }
+    const page = await inspect({
+      limit: request.limit,
+      cursor: request.cursor,
+      filter: registration.options.filter
+    });
+    return {
+      agentId: agent.id,
+      sourceId,
+      kind: "dynamic_context",
+      inspectable: true,
+      items: page.items.map((item) => dynamicContextItem(item)),
+      ...page.nextCursor === void 0 ? {} : { nextCursor: page.nextCursor },
+      ...page.totalCount === void 0 ? {} : { totalCount: page.totalCount }
+    };
+  }
+  const dynamicToolsIndex = dynamicSourceIndex(sourceId, "dynamic_tools");
+  if (dynamicToolsIndex !== void 0) {
+    const registration = agent.agent.dynamicTools[dynamicToolsIndex];
+    if (registration === void 0) {
+      return void 0;
+    }
+    const inspect = inspectFn(registration.index);
+    if (inspect === void 0) {
+      return nonInspectablePage(agent.id, sourceId, "dynamic_tools");
+    }
+    const page = await inspect({
+      limit: request.limit,
+      cursor: request.cursor,
+      filter: registration.options.filter
+    });
+    return {
+      agentId: agent.id,
+      sourceId,
+      kind: "dynamic_tools",
+      inspectable: true,
+      items: page.items.map((item) => dynamicToolItem(item)),
+      ...page.nextCursor === void 0 ? {} : { nextCursor: page.nextCursor },
+      ...page.totalCount === void 0 ? {} : { totalCount: page.totalCount }
+    };
+  }
+  return void 0;
+}
+function inspectFn(index) {
+  if (!isRecord2(index) || typeof index.inspect !== "function") {
+    return void 0;
+  }
+  const inspect = index.inspect;
+  return (request) => inspect.call(index, request);
+}
+function staticKnowledgeItemsPage(agent, request) {
+  const start = Math.max(0, Math.trunc(Number(request.cursor ?? "0")));
+  const page = agent.agent.staticContext.slice(start, start + request.limit);
+  const nextOffset = start + page.length;
+  return {
+    agentId: agent.id,
+    sourceId: staticSourceId(),
+    kind: "static_context",
+    inspectable: true,
+    items: page.map((document) => ({
+      id: document.id,
+      kind: "static_context",
+      text: document.text,
+      ...document.additionalProps === void 0 ? {} : { metadata: jsonObjectFromRecord(document.additionalProps) }
+    })),
+    ...nextOffset < agent.agent.staticContext.length ? { nextCursor: String(nextOffset) } : {},
+    totalCount: agent.agent.staticContext.length
+  };
+}
+function nonInspectablePage(agentId, sourceId, kind) {
+  return {
+    agentId,
+    sourceId,
+    kind,
+    inspectable: false,
+    items: [],
+    message: "This source can be searched at runtime, but it does not expose browseable chunks."
+  };
+}
+function dynamicContextItem(item) {
+  const text = isRecord2(item.document) && typeof item.document.text === "string" ? item.document.text : typeof item.document === "string" ? item.document : void 0;
+  return {
+    id: item.id,
+    kind: "dynamic_context",
+    ...text === void 0 ? { document: toJsonValue2(item.document) } : { text },
+    ...item.metadata === void 0 ? {} : { metadata: jsonObjectFromRecord(item.metadata) }
+  };
+}
+function dynamicToolItem(item) {
+  const document = isRecord2(item.document) ? item.document : {};
+  const definition = isRecord2(document.definition) ? document.definition : {};
+  const toolName = typeof document.toolName === "string" ? document.toolName : typeof definition.name === "string" ? definition.name : item.id;
+  const description = typeof definition.description === "string" ? definition.description : "";
+  return {
+    id: item.id,
+    kind: "dynamic_tool",
+    toolName,
+    description,
+    parameterKeys: parameterKeys(definition.parameters),
+    document: toJsonValue2(item.document),
+    ...item.metadata === void 0 ? {} : { metadata: jsonObjectFromRecord(item.metadata) }
+  };
+}
+function parameterKeys(parameters) {
+  if (!isRecord2(parameters) || !isRecord2(parameters.properties)) {
+    return [];
+  }
+  return Object.keys(parameters.properties);
+}
+function staticSourceId() {
+  return "static-context";
+}
+function dynamicContextSourceId(index) {
+  return `dynamic-context-${index}`;
+}
+function dynamicToolsSourceId(index) {
+  return `dynamic-tools-${index}`;
+}
+function dynamicSourceIndex(sourceId, kind) {
+  const prefix = kind === "dynamic_context" ? "dynamic-context-" : "dynamic-tools-";
+  if (!sourceId.startsWith(prefix)) {
+    return void 0;
+  }
+  const index = Number(sourceId.slice(prefix.length));
+  return Number.isInteger(index) && index >= 0 ? index : void 0;
+}
 async function recentKnowledgeEvidence(traceStore, limit) {
   if (traceStore?.listTraces === void 0) {
     return [];
@@ -2482,7 +2938,7 @@ function pipelineRunReceivedLog(props) {
     message: "Pipeline run request received",
     metadata: cleanMetadata({
       stream: props.stream,
-      inputBytes: byteLength(formatUnknown(props.input)),
+      inputBytes: byteLength2(formatUnknown(props.input)),
       metadataKeys: Object.keys(props.metadata ?? {})
     })
   };
@@ -2512,7 +2968,7 @@ function pipelineRunCompletedLog(props) {
     message: "Pipeline run completed",
     metadata: cleanMetadata({
       durationMs: props.durationMs,
-      outputBytes: byteLength(formatUnknown(props.output))
+      outputBytes: byteLength2(formatUnknown(props.output))
     })
   };
 }
@@ -2598,7 +3054,7 @@ function cleanMetadata(value) {
     Object.entries(value).filter(([, item]) => item !== void 0)
   );
 }
-function byteLength(value) {
+function byteLength2(value) {
   return value === void 0 ? void 0 : new TextEncoder().encode(value).length;
 }
 function formatUnknown(value) {
@@ -3215,7 +3671,7 @@ function registerPipelineRoutes(app, props) {
     if (!props.pipelineMap.has(pipelineId)) {
       return errorResponse(c, 404, "not_found", "Pipeline not found");
     }
-    if (props.store === void 0) {
+    if (props.logStore === void 0) {
       return errorResponse(
         c,
         501,
@@ -3232,7 +3688,7 @@ function registerPipelineRoutes(app, props) {
     if (after === false) {
       return errorResponse(c, 400, "bad_request", "after must be a non-negative integer");
     }
-    const logs = await props.store.listPipelineLogs({
+    const logs = await props.logStore.listPipelineLogs({
       pipelineId,
       limit,
       ...after === void 0 ? {} : { after }
@@ -3243,6 +3699,27 @@ function registerPipelineRoutes(app, props) {
       ...logs.length === limit && last !== void 0 ? { nextCursor: last.sequence } : {}
     });
   });
+  app.get("/pipelines/:pipelineId/runs", async (c) => {
+    const pipelineId = c.req.param("pipelineId");
+    if (!props.pipelineMap.has(pipelineId)) {
+      return errorResponse(c, 404, "not_found", "Pipeline not found");
+    }
+    if (props.runStore === void 0) {
+      return errorResponse(
+        c,
+        501,
+        "unsupported_capability",
+        'Capability "pipelines.runs" is not implemented by this runner',
+        { capability: "pipelines", operation: "runs" }
+      );
+    }
+    const limit = parsePipelineLogLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
+    }
+    const runs = await props.runStore.listPipelineRuns({ pipelineId, limit });
+    return c.json({ runs });
+  });
   app.post("/pipelines/:pipelineId/runs", async (c) => {
     const pipeline = props.pipelineMap.get(c.req.param("pipelineId"));
     if (pipeline === void 0) {
@@ -3254,8 +3731,9 @@ function registerPipelineRoutes(app, props) {
     }
     const runId = globalThis.crypto.randomUUID();
     const startedAt = Date.now();
+    const startedAtIso = new Date(startedAt).toISOString();
     await appendPipelineLog(
-      props.store,
+      props.logStore,
       pipelineRunReceivedLog({
         pipeline,
         runId,
@@ -3264,31 +3742,54 @@ function registerPipelineRoutes(app, props) {
         ...body.metadata === void 0 ? {} : { metadata: body.metadata }
       })
     );
+    await savePipelineRun(props.runStore, {
+      runId,
+      pipelineId: pipeline.id,
+      status: "running",
+      input: body.input,
+      ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+      startedAt: startedAtIso
+    });
     if (body.stream === true) {
       return streamPipelineRun(c, {
         pipeline,
         runId,
         input: body.input,
         startedAt,
-        ...props.store === void 0 ? {} : { store: props.store }
+        startedAtIso,
+        ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+        ...props.logStore === void 0 ? {} : { logStore: props.logStore },
+        ...props.runStore === void 0 ? {} : { runStore: props.runStore }
       });
     }
     try {
-      await appendPipelineLog(props.store, pipelineRunStartedLog(pipeline, runId));
+      await appendPipelineLog(props.logStore, pipelineRunStartedLog(pipeline, runId));
       const output = await pipeline.pipeline.run(body.input, {
         observer: {
           async onEvent(event) {
-            await appendPipelineLog(props.store, pipelineStageLog(pipeline.id, runId, event));
+            await appendPipelineLog(props.logStore, pipelineStageLog(pipeline.id, runId, event));
           }
         }
       });
       const jsonOutput = toJsonValue3(output);
+      const endedAt = Date.now();
+      await savePipelineRun(props.runStore, {
+        runId,
+        pipelineId: pipeline.id,
+        status: "success",
+        input: body.input,
+        output: jsonOutput,
+        ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+        startedAt: startedAtIso,
+        endedAt: new Date(endedAt).toISOString(),
+        durationMs: endedAt - startedAt
+      });
       await appendPipelineLog(
-        props.store,
+        props.logStore,
         pipelineRunCompletedLog({
           pipelineId: pipeline.id,
           runId,
-          durationMs: Date.now() - startedAt,
+          durationMs: endedAt - startedAt,
           output: jsonOutput
         })
       );
@@ -3299,8 +3800,20 @@ function registerPipelineRoutes(app, props) {
       };
       return c.json(response);
     } catch (error) {
+      const endedAt = Date.now();
+      await savePipelineRun(props.runStore, {
+        runId,
+        pipelineId: pipeline.id,
+        status: "error",
+        input: body.input,
+        error: serializeError2(error),
+        ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+        startedAt: startedAtIso,
+        endedAt: new Date(endedAt).toISOString(),
+        durationMs: endedAt - startedAt
+      });
       await appendPipelineLog(
-        props.store,
+        props.logStore,
         pipelineRunFailedLog(pipeline.id, runId, error, startedAt)
       );
       return errorResponse(c, 500, "internal_error", "Pipeline run failed", serializeError2(error));
@@ -3336,13 +3849,13 @@ function streamPipelineRun(c, props) {
   );
 }
 async function* pipelineRunEvents(props) {
-  yield* emitPipelineLog(props.store, pipelineRunStartedLog(props.pipeline, props.runId));
+  yield* emitPipelineLog(props.logStore, pipelineRunStartedLog(props.pipeline, props.runId));
   const events = new AsyncEventQueue();
   const run = props.pipeline.pipeline.run(props.input, {
     observer: {
       async onEvent(event) {
         const log = await appendPipelineLog(
-          props.store,
+          props.logStore,
           pipelineStageLog(props.pipeline.id, props.runId, event)
         );
         if (log !== void 0) {
@@ -3352,12 +3865,24 @@ async function* pipelineRunEvents(props) {
     }
   }).then(async (output) => {
     const jsonOutput = toJsonValue3(output);
+    const endedAt = Date.now();
+    await savePipelineRun(props.runStore, {
+      runId: props.runId,
+      pipelineId: props.pipeline.id,
+      status: "success",
+      input: props.input,
+      output: jsonOutput,
+      ...props.metadata === void 0 ? {} : { metadata: props.metadata },
+      startedAt: props.startedAtIso,
+      endedAt: new Date(endedAt).toISOString(),
+      durationMs: endedAt - props.startedAt
+    });
     const log = await appendPipelineLog(
-      props.store,
+      props.logStore,
       pipelineRunCompletedLog({
         pipelineId: props.pipeline.id,
         runId: props.runId,
-        durationMs: Date.now() - props.startedAt,
+        durationMs: endedAt - props.startedAt,
         output: jsonOutput
       })
     );
@@ -3371,8 +3896,20 @@ async function* pipelineRunEvents(props) {
       output: jsonOutput
     });
   }).catch(async (error) => {
+    const endedAt = Date.now();
+    await savePipelineRun(props.runStore, {
+      runId: props.runId,
+      pipelineId: props.pipeline.id,
+      status: "error",
+      input: props.input,
+      error: serializeError2(error),
+      ...props.metadata === void 0 ? {} : { metadata: props.metadata },
+      startedAt: props.startedAtIso,
+      endedAt: new Date(endedAt).toISOString(),
+      durationMs: endedAt - props.startedAt
+    });
     const log = await appendPipelineLog(
-      props.store,
+      props.logStore,
       pipelineRunFailedLog(props.pipeline.id, props.runId, error, props.startedAt)
     );
     if (log !== void 0) {
@@ -3392,6 +3929,9 @@ async function* pipelineRunEvents(props) {
     await run;
   }
 }
+async function savePipelineRun(store, input) {
+  return store?.savePipelineRun(input);
+}
 async function parsePipelineRunRequest(c) {
   let body;
   try {
@@ -3807,7 +4347,7 @@ function runCompletedLog(props) {
     metadata: cleanMetadata2({
       durationMs: props.durationMs,
       usage: usageSummary(props.usage),
-      outputBytes: byteLength2(props.output),
+      outputBytes: byteLength3(props.output),
       messageCount: props.messageCount
     })
   };
@@ -3871,7 +4411,7 @@ function logsFromStreamEvent(props) {
           turn: event.turn,
           toolName: event.toolCall.function.name,
           callId: event.toolCall.callId ?? event.toolCall.id,
-          argumentBytes: byteLength2(formatUnknown2(event.toolCall.function.arguments))
+          argumentBytes: byteLength3(formatUnknown2(event.toolCall.function.arguments))
         })
       }
     ];
@@ -3890,8 +4430,8 @@ function logsFromStreamEvent(props) {
           toolName: event.toolName,
           callId: event.toolCallId,
           internalCallId: event.internalCallId,
-          argumentBytes: byteLength2(event.args),
-          resultBytes: byteLength2(event.result)
+          argumentBytes: byteLength3(event.args),
+          resultBytes: byteLength3(event.result)
         })
       }
     ];
@@ -3944,7 +4484,7 @@ function logsFromStreamEvent(props) {
           callId: event.approval.callId,
           status: event.approval.status,
           hasReason: event.approval.reason !== void 0,
-          argumentBytes: byteLength2(event.approval.args)
+          argumentBytes: byteLength3(event.approval.args)
         })
       }
     ];
@@ -3983,7 +4523,7 @@ function logsFromStreamEvent(props) {
           callId: event.question.callId,
           status: event.question.status,
           questionCount: event.question.questions.length,
-          argumentBytes: byteLength2(event.question.args)
+          argumentBytes: byteLength3(event.question.args)
         })
       }
     ];
@@ -4037,7 +4577,7 @@ function childAgentLog(event, sessionId, runId) {
           childTurn: child.turn,
           toolName: child.toolCall.function.name,
           callId: child.toolCall.callId ?? child.toolCall.id,
-          argumentBytes: byteLength2(formatUnknown2(child.toolCall.function.arguments))
+          argumentBytes: byteLength3(formatUnknown2(child.toolCall.function.arguments))
         })
       }
     ];
@@ -4059,7 +4599,7 @@ function childAgentLog(event, sessionId, runId) {
           childTurn: child.turn,
           toolName: child.toolName,
           callId: child.toolCallId,
-          resultBytes: byteLength2(child.result)
+          resultBytes: byteLength3(child.result)
         })
       }
     ];
@@ -4097,7 +4637,7 @@ function childAgentLog(event, sessionId, runId) {
           agentId: event.agentId,
           hasAgentName: event.agentName !== void 0,
           usage: usageSummary(child.usage),
-          outputBytes: byteLength2(child.output),
+          outputBytes: byteLength3(child.output),
           messageCount: child.messages.length
         })
       }
@@ -4128,14 +4668,14 @@ function messageSummary(message) {
     return {
       role: "user",
       contentKind: "text",
-      byteLength: byteLength2(message)
+      byteLength: byteLength3(message)
     };
   }
   return {
     role: message.role,
     contentKind: Array.isArray(message.content) ? "parts" : "text",
     partCount: Array.isArray(message.content) ? message.content.length : 1,
-    byteLength: byteLength2(formatUnknown2(message.content))
+    byteLength: byteLength3(formatUnknown2(message.content))
   };
 }
 function usageSummary(value) {
@@ -4179,7 +4719,7 @@ function cleanJsonValue(value) {
 function numericValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function byteLength2(value) {
+function byteLength3(value) {
   return value === void 0 ? 0 : new TextEncoder().encode(value).byteLength;
 }
 function formatUnknown2(value) {
@@ -4599,7 +5139,8 @@ function createStudioApp(options) {
   registerPipelineRoutes(app, {
     pipelines,
     pipelineMap,
-    ...stores.pipelineLogs === void 0 ? {} : { store: stores.pipelineLogs }
+    ...stores.pipelineLogs === void 0 ? {} : { logStore: stores.pipelineLogs },
+    ...stores.pipelineRuns === void 0 ? {} : { runStore: stores.pipelineRuns }
   });
   app.post("/agents/:agentId/runs", async (c) => {
     const agentId = c.req.param("agentId");