@ekairos/structure 1.22.46-beta.development.0 → 1.22.47-beta.development.0

package/dist/steps/commitFromEvents.step.js

@@ -1,24 +1,5 @@
 import { linkStructureOutputFileToContextByKey } from "../contextPersistence.js";
-function isToolCompletePart(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const v = value;
-    return v.type === "tool-complete" && v.state === "output-available";
-}
-function findLatestCompleteToolOutput(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-        const parts = events[i]?.content?.parts;
-        if (!Array.isArray(parts))
-            continue;
-        for (let j = parts.length - 1; j >= 0; j--) {
-            const p = parts[j];
-            if (!isToolCompletePart(p))
-                continue;
-            return p.output;
-        }
-    }
-    return null;
-}
+import { findLatestCompleteToolOutput } from "./completeOutput.js";
 export async function structureCommitFromEventsStep(params) {
     "use step";
     const contextKey = `structure:${params.structureId}`;

package/dist/steps/completeOutput.d.ts

@@ -0,0 +1 @@
+export declare function findLatestCompleteToolOutput(events: unknown[]): unknown | null;

package/dist/steps/completeOutput.js

@@ -0,0 +1,43 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    return value;
+}
+function readPart(value) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const nestedPart = asRecord(record.part);
+    return nestedPart ?? record;
+}
+function readCompleteOutputFromPart(value) {
+    const part = readPart(value);
+    if (!part)
+        return null;
+    if (part.type === "tool-complete" && part.state === "output-available") {
+        return part.output ?? null;
+    }
+    if (part.type !== "action")
+        return null;
+    const content = asRecord(part.content);
+    if (content?.status !== "completed" ||
+        content?.actionName !== "complete") {
+        return null;
+    }
+    return content.output ?? null;
+}
+export function findLatestCompleteToolOutput(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = asRecord(events[i]);
+        const content = asRecord(event?.content);
+        const parts = Array.isArray(content?.parts) ? content.parts : null;
+        if (!parts)
+            continue;
+        for (let j = parts.length - 1; j >= 0; j--) {
+            const output = readCompleteOutputFromPart(parts[j]);
+            if (output !== null)
+                return output;
+        }
+    }
+    return null;
+}

package/dist/steps/ensureExecutionTrail.step.js

@@ -85,6 +85,10 @@ export async function ensureExecutionTrailStep(params) {
     });
     if (!outputItem?.id)
         return;
+    const context = await store.getContext?.({ key: params.contextKey });
+    if (context?.status === "closed" && store?.updateContextStatus) {
+        await store.updateContextStatus({ key: params.contextKey }, "open_idle");
+    }
     const execution = await store.createExecution({ key: params.contextKey }, requestItemId, outputItem.id);
     await store.linkItemToExecution({
         itemId: requestItemId,

package/dist/steps/persistObjectFromStory.step.js

@@ -1,3 +1,4 @@
+import { findLatestCompleteToolOutput } from "./completeOutput.js";
 function extractJsonObject(text) {
     const trimmed = text.trim();
     if (!trimmed)
@@ -40,10 +41,37 @@ export async function persistObjectResultFromStoryStep(params) {
     const runtime = (await getContextRuntime(params.env));
     const store = runtime.store;
     const contextKey = `structure:${params.datasetId}`;
-    const events = await store.getEvents({ key: contextKey });
+    const events = typeof store.getItems === "function"
+        ? await store.getItems({ key: contextKey })
+        : await store.getEvents({ key: contextKey });
     const { structurePatchContextContentStep, structureGetContextStep } = await import("../dataset/steps.js");
     const ctxResult = await structureGetContextStep({ env: params.env, contextKey });
     const existingContent = ctxResult.ok ? (ctxResult.data?.content ?? {}) : {};
+    const completedOutput = findLatestCompleteToolOutput(events ?? []);
+    if (completedOutput?.success === true && "result" in completedOutput) {
+        const patchResult = await structurePatchContextContentStep({
+            env: params.env,
+            contextKey,
+            patch: {
+                structure: {
+                    kind: "ekairos.structure",
+                    version: 1,
+                    structureId: params.datasetId,
+                    updatedAt: Date.now(),
+                    state: "completed",
+                    outputs: {
+                        ...(existingContent?.structure?.outputs ?? {}),
+                        object: { value: completedOutput.result },
+                    },
+                },
+            },
+        });
+        if (!patchResult?.ok) {
+            const err = patchResult?.error ?? "Failed to persist object result";
+            throw new Error(err);
+        }
+        return { ok: true };
+    }
     for (let i = events.length - 1; i >= 0; i--) {
         const e = events[i];
         const parts = e?.content?.parts;

package/dist/structure.d.ts

@@ -1,3 +1,4 @@
+import type { ContextModelInit } from "@ekairos/events";
 import { type StructureRowsOutputPagingCursor } from "./rowsOutputPaging.js";
 import type { SandboxConfig } from "@ekairos/sandbox";
 export type StructureSource = {
@@ -66,10 +67,32 @@ export type StructureBuildResult = {
      */
     dataset?: any;
 };
+type StructureStoryConfig = {
+    datasetId: string;
+    sources: StructureSource[];
+    instructions?: string;
+    mode: StructureMode;
+    output: StructureOutput;
+    outputSchema?: any;
+    sandboxId?: string;
+    model?: ContextModelInit;
+    sandboxConfig?: SandboxConfig;
+};
+export declare function structureRunStoryStep<Env extends {
+    orgId: string;
+}>(params: {
+    env: Env;
+    contextKey: string;
+    config: StructureStoryConfig;
+    event: any;
+}): Promise<{
+    ok: boolean;
+}>;
 export declare function structure<Env extends {
     orgId: string;
 }>(env: Env, opts?: {
     datasetId?: string;
+    model?: ContextModelInit;
     sandboxConfig?: SandboxConfig;
 }): {
     datasetId: string;
@@ -79,5 +102,7 @@ export declare function structure<Env extends {
     schema(schema: any): /*elided*/ any;
     asRows(): /*elided*/ any;
     asObject(): /*elided*/ any;
+    model(nextModel: ContextModelInit): /*elided*/ any;
     build(userPrompt?: string): Promise<StructureBuildResult>;
 };
+export {};

package/dist/structure.js

@@ -410,6 +410,35 @@ function createStructureStoryDefinition(config) {
         .model(model);
     return { datasetId, story };
 }
+export async function structureRunStoryStep(params) {
+    "use step";
+    const { story, datasetId } = createStructureStoryDefinition(params.config);
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const runtime = await getContextRuntime(params.env);
+    const shell = await story.react(params.event, {
+        env: params.env,
+        runtime,
+        context: { key: params.contextKey },
+        durable: false,
+        options: {
+            silent: true,
+            preventClose: true,
+            sendFinish: false,
+            maxIterations: 40,
+            maxModelSteps: 10,
+        },
+    });
+    await shell.run;
+    // Tools are intentionally pure: persist completion outputs post-react by reading tool results from events.
+    const commit = await structureCommitFromEventsStep({
+        env: params.env,
+        structureId: datasetId,
+    });
+    if (!commit.ok) {
+        throw new Error(commit.error);
+    }
+    return { ok: true };
+}
 export function structure(env, opts) {
     const datasetId = opts?.datasetId ?? createUuidV4();
     const sources = [];
@@ -417,6 +446,7 @@ export function structure(env, opts) {
     let mode = "auto";
     let output = "rows";
     let outputSchema;
+    let model = opts?.model;
     const sandboxConfig = opts?.sandboxConfig;
     const api = {
         datasetId,
@@ -446,6 +476,10 @@ export function structure(env, opts) {
             output = "object";
             return api;
         },
+        model(nextModel) {
+            model = nextModel;
+            return api;
+        },
         async build(userPrompt) {
             // Guardrail: structure build MUST run inside workflow runtime ("use workflow").
             const workflowMeta = assertRunningInsideWorkflow({ datasetId });
@@ -458,6 +492,7 @@ export function structure(env, opts) {
                 mode,
                 output,
                 outputSchema,
+                model,
                 sandboxConfig,
             };
             const { story } = createStructureStoryDefinition(storyConfig);
@@ -495,18 +530,12 @@ export function structure(env, opts) {
                 }
             }
             async function runStory(evt) {
-                const shell = await story.react(evt, {
+                await structureRunStoryStep({
                     env,
-                    context: { key: contextKey },
-                    durable: false,
-                    options: { silent: true, preventClose: true, sendFinish: false, maxIterations: 40, maxModelSteps: 10 },
+                    contextKey,
+                    config: storyConfig,
+                    event: evt,
                 });
-                await shell.run;
-                // Tools are intentionally pure: persist completion outputs post-react by reading tool results from events.
-                const commit = await structureCommitFromEventsStep({ env, structureId: datasetId });
-                if (!commit.ok) {
-                    throw new Error(commit.error);
-                }
             }
             async function getContextOrThrow() {
                 const ctxResult = await structureGetContextStep({ env, contextKey });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/structure",
-  "version": "1.22.46-beta.development.0",
+  "version": "1.22.47-beta.development.0",
   "description": "Ekairos Structure - Unified structured extraction (rows or object) from file/text/dataset inputs",
   "type": "module",
   "main": "dist/index.js",
@@ -36,8 +36,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.46-beta.development.0",
-    "@ekairos/sandbox": "^1.22.46-beta.development.0",
+    "@ekairos/domain": "^1.22.47-beta.development.0",
+    "@ekairos/sandbox": "^1.22.47-beta.development.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "ai": "^5.0.95",