@purista/harness 1.2.2 → 1.2.4

package/dist/harness/defineHarness.d.ts

@@ -552,7 +552,15 @@ export interface RunSummary {
     agentCalls: number;
     error?: SerializedError;
 }
-/** Harness streaming events emitted from `session.workflows.<id>.stream(...)`. */
+/**
+ * Harness streaming events emitted from `session.workflows.<id>.stream(...)`.
+ *
+ * `text(...)` and `object(...)` model calls return final results and do not
+ * expose partial output. Consumed model streams are private by default.
+ * `model.delta`, `model.object.partial`, and streamed `model.object` are
+ * emitted only when that `textStream(...)` or `objectStream(...)` call passes
+ * `{ emitRunEvents: true }`.
+ */
 export type RunEvent = {
     type: 'run.started';
     runId: string;
@@ -578,7 +586,10 @@ export type RunEvent = {
 } | {
     type: 'model.delta';
     runId: string;
-    agentId: string;
+    streamId: string;
+    agentId?: string;
+    workflowId?: string;
+    modelAlias?: string;
     delta: string;
 } | {
     type: 'tool.started';
@@ -603,12 +614,18 @@ export type RunEvent = {
 } | {
     type: 'model.object.partial';
     runId: string;
+    streamId: string;
     agentId?: string;
+    workflowId?: string;
+    modelAlias?: string;
     partial: JsonValue;
 } | {
     type: 'model.object';
     runId: string;
     agentId?: string;
+    workflowId?: string;
+    modelAlias?: string;
+    streamId?: string;
     object: JsonValue;
     usage?: TokenUsage;
 } | {

package/dist/models/registry.d.ts

@@ -2,11 +2,18 @@ import type { EmbeddingRequest, EmbeddingResponse, ContentPart, ModelAlias, Mode
 import type { TelemetryShim } from '../telemetry/index.js';
 import type { JsonValue } from './json.js';
 export interface ModelInvokeContext {
-    harnessName: string;
-    sessionId: string;
-    runId: string;
+    /** Harness instance name used for telemetry and run-event attribution. */
+    harnessName?: string;
+    /** Session id used for telemetry and run-event attribution. */
+    sessionId?: string;
+    /** Run id used for telemetry and run-event attribution. */
+    runId?: string;
+    /** Workflow id when the model call belongs to a workflow run. */
     workflowId?: string;
+    /** Agent id when the model call belongs to an agent run. */
     agentId?: string;
+    /** Mirrors consumed stream chunks into the enclosing session `RunEvent` stream. Defaults to false. */
+    emitRunEvents?: boolean;
 }
 type TextPart = Extract<ContentPart, {
     kind: 'text';

package/dist/ports/base-model-provider.d.ts

@@ -45,6 +45,7 @@ export declare abstract class BaseModelProvider implements ModelProvider {
     protected doObjectStream<T extends JsonValue = JsonValue>(_req: ObjectRequest<T>): AsyncIterable<ObjectStreamChunk<T>>;
     protected doEmbed(_req: EmbeddingRequest): Promise<EmbeddingResponse>;
     protected doRerank(_req: RerankRequest): Promise<RerankResponse>;
+    protected getLogger(): Logger | undefined;
     protected normalizeError(error: unknown, method: ProviderMethod, req: ProviderRequest): HarnessError;
     private call;
     private stream;

package/dist/ports/base-model-provider.js

@@ -67,6 +67,9 @@ export class BaseModelProvider {
     doRerank(_req) {
         throw this.methodMissing('rerank');
     }
+    getLogger() {
+        return this.logger;
+    }
     normalizeError(error, method, req) {
         if (error instanceof HarnessError)
             return error;

package/dist/sessions/index.js

@@ -433,7 +433,12 @@ export function createSessionHarness(definition) {
                     input,
                     history: await definition.state.listMessages(sessionId),
                     agent,
-                    models: modelRegistry,
+                    models: withRunEventModelRegistry(modelRegistry, {
+                        harnessName: definition.name,
+                        sessionId,
+                        runId,
+                        agentId
+                    }, emit),
                     skills: resolvedSkills,
                     customTools: definition.tools,
                     mcpRegistry,
@@ -585,7 +590,12 @@ export function createSessionHarness(definition) {
                         signal: runSignal.signal,
                         runId,
                         sessionId,
-                        models: modelRegistry,
+                        models: withRunEventModelRegistry(modelRegistry, {
+                            harnessName: definition.name,
+                            sessionId,
+                            runId,
+                            workflowId
+                        }, emit),
                         metadata: opts?.metadata ?? {},
                         metrics: workflowMetrics,
                         memory,
@@ -615,7 +625,13 @@ export function createSessionHarness(definition) {
                                         input: agentInput,
                                         history: await definition.state.listMessages(sessionId),
                                         agent: agent,
-                                        models: modelRegistry,
+                                        models: withRunEventModelRegistry(modelRegistry, {
+                                            harnessName: definition.name,
+                                            sessionId,
+                                            runId,
+                                            workflowId,
+                                            agentId
+                                        }, emit),
                                         skills: resolvedSkills,
                                         customTools: definition.tools,
                                         mcpRegistry,
@@ -764,6 +780,100 @@ export function createSessionHarness(definition) {
         }
     }
 }
+function withRunEventModelRegistry(models, context, emitEvent) {
+    return Object.fromEntries(Object.entries(models).map(([alias, handle]) => [alias, withRunEventModelHandle(alias, handle, context, emitEvent)]));
+}
+function withRunEventModelHandle(alias, handle, context, emitEvent) {
+    if (!handle || typeof handle !== 'object')
+        return handle;
+    const source = handle;
+    const wrapped = { ...source };
+    for (const method of ['text', 'object', 'embed', 'rerank']) {
+        const fn = source[method];
+        if (typeof fn !== 'function')
+            continue;
+        wrapped[method] = (req, signal, ctx) => fn.call(source, req, signal, mergeModelRunContext(context, ctx));
+    }
+    const textStream = source['textStream'];
+    if (typeof textStream === 'function') {
+        wrapped['textStream'] = (req, signal, ctx) => {
+            const streamContext = modelStreamRunContext(context, ctx, alias);
+            return emitTextStreamRunEvents(textStream.call(source, req, signal, streamContext), streamContext, emitEvent);
+        };
+    }
+    const objectStream = source['objectStream'];
+    if (typeof objectStream === 'function') {
+        wrapped['objectStream'] = (req, signal, ctx) => {
+            const streamContext = modelStreamRunContext(context, ctx, alias);
+            return emitObjectStreamRunEvents(objectStream.call(source, req, signal, streamContext), streamContext, emitEvent);
+        };
+    }
+    return wrapped;
+}
+function mergeModelRunContext(context, override) {
+    return { ...context, ...(override ?? {}) };
+}
+function modelStreamRunContext(context, override, alias) {
+    const merged = mergeModelRunContext(context, override);
+    return {
+        ...merged,
+        modelAlias: alias,
+        ...(merged.emitRunEvents === true ? { streamId: `model_${ulid()}` } : {})
+    };
+}
+async function* emitTextStreamRunEvents(stream, context, emitEvent) {
+    for await (const chunk of stream) {
+        if (context.emitRunEvents === true && isTextDeltaChunk(chunk)) {
+            await emitEvent({
+                type: 'model.delta',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                streamId: context.streamId,
+                delta: chunk.text
+            });
+        }
+        yield chunk;
+    }
+}
+async function* emitObjectStreamRunEvents(stream, context, emitEvent) {
+    for await (const chunk of stream) {
+        if (context.emitRunEvents === true && isObjectPartialChunk(chunk)) {
+            await emitEvent({
+                type: 'model.object.partial',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                streamId: context.streamId,
+                partial: chunk.partial
+            });
+        }
+        else if (context.emitRunEvents === true && isObjectFinishChunk(chunk)) {
+            await emitEvent({
+                type: 'model.object',
+                runId: context.runId,
+                ...(context.agentId ? { agentId: context.agentId } : {}),
+                ...(context.workflowId ? { workflowId: context.workflowId } : {}),
+                ...(context.modelAlias ? { modelAlias: context.modelAlias } : {}),
+                ...(context.streamId ? { streamId: context.streamId } : {}),
+                object: chunk.object,
+                ...(chunk.usage ? { usage: chunk.usage } : {})
+            });
+        }
+        yield chunk;
+    }
+}
+function isTextDeltaChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'delta' && typeof chunk.text === 'string');
+}
+function isObjectPartialChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'partial');
+}
+function isObjectFinishChunk(chunk) {
+    return Boolean(chunk && typeof chunk === 'object' && chunk.kind === 'finish' && Object.prototype.hasOwnProperty.call(chunk, 'object'));
+}
 function configureHarnessAdapters(context, models, state, sandbox, memory, tools) {
     const seen = new Set();
     for (const alias of Object.values(models)) {
@@ -940,12 +1050,12 @@ function sanitizeEventForPersistence(event) {
         case 'model.message':
             return { agentId: event.agentId, message: '[redacted]' };
         case 'model.delta':
-            return { agentId: event.agentId, delta: '[redacted]' };
+            return { ...modelStreamEventMeta(event), delta: '[redacted]' };
         case 'model.object.partial':
-            return { ...(event.agentId ? { agentId: event.agentId } : {}), partial: '[redacted]' };
+            return { ...modelStreamEventMeta(event), partial: '[redacted]' };
         case 'model.object':
             return {
-                ...(event.agentId ? { agentId: event.agentId } : {}),
+                ...modelStreamEventMeta(event),
                 object: '[redacted]',
                 ...(event.usage ? { usage: event.usage } : {})
             };
@@ -973,6 +1083,14 @@ function sanitizeEventForPersistence(event) {
         }
     }
 }
+function modelStreamEventMeta(event) {
+    return {
+        ...(event.agentId ? { agentId: event.agentId } : {}),
+        ...(event.workflowId ? { workflowId: event.workflowId } : {}),
+        ...(event.modelAlias ? { modelAlias: event.modelAlias } : {}),
+        ...(event.streamId ? { streamId: event.streamId } : {})
+    };
+}
 function isJsonRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purista/harness",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Self-hosted enterprise agent harness for typed tools, agents, workflows, state, sandboxing, and telemetry.",
   "type": "module",
   "main": "dist/index.js",