@kortyx/agent 0.4.1 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.5.1](https://github.com/kortyx-io/kortyx/compare/agent-v0.5.0...agent-v0.5.1) (2026-02-17)
+
+
+### Bug Fixes
+
+* **build:** align package tsconfig with shared lib baseline ([48d2b57](https://github.com/kortyx-io/kortyx/commit/48d2b5765fefbb5fcbbe548e749e7b5f51b450b9))
+* **build:** wire tsup for publishable packages ([e7b1b5c](https://github.com/kortyx-io/kortyx/commit/e7b1b5c28af55becffc137233dd92d8953d7cb8e))
+* **dev:** restore tsc watch flow for local workspace ([4305823](https://github.com/kortyx-io/kortyx/commit/430582372cad466bf28af554042aa11bdb8bf027))
+
+## [0.5.0](https://github.com/kortyx-io/kortyx/compare/agent-v0.4.1...agent-v0.5.0) (2026-02-17)
+
+
+### Features
+
+* **agent:** strict createAgent and unify useReason streaming ([6725f97](https://github.com/kortyx-io/kortyx/commit/6725f976fc32083fb7d2590f1353d16a99afb46f))
+* **kortyx:** add browser-safe chat streaming adapters ([c7eb98e](https://github.com/kortyx-io/kortyx/commit/c7eb98e06781a708c79f143ba725efb69d35709e))
+* make createAgent strict/declarative and split providers ([1d252f2](https://github.com/kortyx-io/kortyx/commit/1d252f2dcd51622f821715c0fffb13733aeb3cae))
+
+
+### Bug Fixes
+
+* **agent:** remove eager provider registration guard ([8da4059](https://github.com/kortyx-io/kortyx/commit/8da40592d55bb31800a4d85edcd49795ddf09a29))
+* **agent:** simplify stream transformer and interrupt orchestration ([d0b5847](https://github.com/kortyx-io/kortyx/commit/d0b58475e139e070fd9ca1a68b71395642ac32d5))
+
 ## [0.4.1](https://github.com/kortyx-io/kortyx/compare/agent-v0.4.0...agent-v0.4.1) (2026-02-15)
 
 

package/dist/browser-DxBPQjOI.d.ts

@@ -0,0 +1,21 @@
+import { StreamChunk } from '@kortyx/stream/browser';
+
+type ChatMessage = {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp?: number | undefined;
+    id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+};
+
+interface StreamChatFromRouteArgs {
+    endpoint: string;
+    sessionId: string;
+    workflowId?: string | undefined;
+    messages: ChatMessage[];
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string> | undefined;
+}
+declare function streamChatFromRoute(args: StreamChatFromRouteArgs): AsyncGenerator<StreamChunk, void, void>;
+
+export { type ChatMessage as C, type StreamChatFromRouteArgs as S, streamChatFromRoute as s };

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export { S as StreamChatFromRouteArgs, s as streamChatFromRoute } from './browser-DxBPQjOI.js';
+import '@kortyx/stream/browser';

package/dist/browser.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  streamChatFromRoute: () => streamChatFromRoute
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/adapters/http-client.ts
+var import_browser = require("@kortyx/stream/browser");
+async function* streamChatFromRoute(args) {
+  yield* (0, import_browser.streamFromRoute)({
+    endpoint: args.endpoint,
+    ...args.fetchImpl ? { fetchImpl: args.fetchImpl } : {},
+    ...args.headers ? { headers: args.headers } : {},
+    body: {
+      sessionId: args.sessionId,
+      ...args.workflowId ? { workflowId: args.workflowId } : {},
+      messages: args.messages
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamChatFromRoute
+});
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/browser.ts","../src/adapters/http-client.ts"],"sourcesContent":["// Browser-safe exports for client bundles.\n// Keep this file free of Node-only imports (fs, path, etc).\n\nexport type { StreamChatFromRouteArgs } from \"./adapters/http-client\";\nexport { streamChatFromRoute } from \"./adapters/http-client\";\n","import { type StreamChunk, streamFromRoute } from \"@kortyx/stream/browser\";\nimport type { ChatMessage } from \"../types/chat-message\";\n\nexport interface StreamChatFromRouteArgs {\n  endpoint: string;\n  sessionId: string;\n  workflowId?: string | undefined;\n  messages: ChatMessage[];\n  fetchImpl?: typeof fetch;\n  headers?: Record<string, string> | undefined;\n}\n\nexport async function* streamChatFromRoute(\n  args: StreamChatFromRouteArgs,\n): AsyncGenerator<StreamChunk, void, void> {\n  yield* streamFromRoute({\n    endpoint: args.endpoint,\n    ...(args.fetchImpl ? { fetchImpl: args.fetchImpl } : {}),\n    ...(args.headers ? { headers: args.headers } : {}),\n    body: {\n      sessionId: args.sessionId,\n      ...(args.workflowId ? { workflowId: args.workflowId } : {}),\n      messages: args.messages,\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,qBAAkD;AAYlD,gBAAuB,oBACrB,MACyC;AACzC,aAAO,gCAAgB;AAAA,IACrB,UAAU,KAAK;AAAA,IACf,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;AAAA,IACtD,GAAI,KAAK,UAAU,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;AAAA,IAChD,MAAM;AAAA,MACJ,WAAW,KAAK;AAAA,MAChB,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,MACzD,UAAU,KAAK;AAAA,IACjB;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/index.d.ts

@@ -1,12 +1,136 @@
-export type { CreateAgentArgs } from "./chat/create-agent";
-export { createAgent } from "./chat/create-agent";
-export type { ProcessChatArgs } from "./chat/process-chat";
-export { processChat } from "./chat/process-chat";
-export type { ApplyResumeSelection, ResumeMeta, } from "./interrupt/resume-handler";
-export { parseResumeMeta, tryPrepareResumeStream, } from "./interrupt/resume-handler";
-export type { CompiledGraphLike, OrchestrateArgs, SaveMemoryFn, SelectWorkflowFn, } from "./orchestrator";
-export { orchestrateGraphStream } from "./orchestrator";
-export { transformGraphStreamForUI } from "./stream/transform-graph-stream-for-ui";
-export type { ChatMessage } from "./types/chat-message";
-export { extractLatestUserMessage } from "./utils/extract-latest-message";
-//# sourceMappingURL=index.d.ts.map
+import { WorkflowDefinition, GraphState } from '@kortyx/core';
+import { GetProviderFn } from '@kortyx/providers';
+import { WorkflowRegistry, FrameworkAdapter, PendingRequestRecord } from '@kortyx/runtime';
+import { C as ChatMessage } from './browser-DxBPQjOI.js';
+export { S as StreamChatFromRouteArgs, s as streamChatFromRoute } from './browser-DxBPQjOI.js';
+import { MemoryAdapter } from '@kortyx/memory';
+import { StreamChunk } from '@kortyx/stream';
+import { StreamEvent } from '@langchain/core/tracers/log_stream';
+import '@kortyx/stream/browser';
+
+interface AgentSessionConfig {
+    id?: string | undefined;
+}
+interface AgentMemoryConfig {
+    enabled?: boolean | undefined;
+    namespace?: string | undefined;
+    ttlMs?: number | undefined;
+}
+interface AgentProcessOptions {
+    sessionId?: string | undefined;
+    workflowId?: string | undefined;
+    workflow?: string | undefined;
+}
+interface CreateAgentArgs {
+    getProvider?: GetProviderFn | undefined;
+    workflows?: WorkflowDefinition[];
+    workflowsDir?: string;
+    workflowRegistry?: WorkflowRegistry;
+    fallbackWorkflowId?: string;
+    defaultWorkflowId?: string;
+    frameworkAdapter?: FrameworkAdapter;
+    session?: AgentSessionConfig;
+    memory?: AgentMemoryConfig;
+}
+interface Agent {
+    processChat: (messages: ChatMessage[], options?: AgentProcessOptions) => Promise<Response>;
+}
+declare function createAgent(args: CreateAgentArgs): Agent;
+
+type ChatRequestBody = {
+    sessionId: string;
+    workflowId?: string | undefined;
+    messages: ChatMessage[];
+};
+declare function parseChatRequestBody(value: unknown): ChatRequestBody;
+declare function processChatRequestBody(args: {
+    agent: Agent;
+    body: ChatRequestBody;
+}): Promise<Response>;
+declare function createChatRouteHandler(args: {
+    agent: Agent;
+    errorStatus?: number | undefined;
+}): (request: Request) => Promise<Response>;
+
+type SelectWorkflowFn = (workflowId: string) => Promise<WorkflowDefinition>;
+type SaveMemoryFn = (sessionId: string, state: GraphState) => Promise<void>;
+interface CompiledGraphLike {
+    config?: Record<string, unknown>;
+    streamEvents: (state: GraphState, options?: {
+        version?: string;
+        configurable?: Record<string, unknown>;
+    }) => AsyncIterable<unknown> | AsyncGenerator<unknown>;
+}
+interface OrchestrateArgs {
+    sessionId?: string;
+    runId: string;
+    graph: CompiledGraphLike;
+    state: GraphState;
+    config: Record<string, unknown>;
+    selectWorkflow: SelectWorkflowFn;
+    frameworkAdapter?: FrameworkAdapter;
+}
+/**
+ * Orchestrates LangGraph execution with mid-stream transitions emitted via
+ * ctx.emit("transition", ...).
+ */
+declare function orchestrateGraphStream({ sessionId, runId, graph, state, config, selectWorkflow, frameworkAdapter, }: OrchestrateArgs): Promise<NodeJS.ReadableStream>;
+
+interface ResumeMeta {
+    token: string;
+    requestId: string;
+    selected: string[];
+    cancel?: boolean;
+}
+type ApplyResumeSelection = (args: {
+    pending: PendingRequestRecord;
+    selected: string[];
+}) => Record<string, unknown> | null | undefined;
+declare function parseResumeMeta(msg: ChatMessage | undefined): ResumeMeta | null;
+interface TryResumeArgs {
+    lastMessage: ChatMessage | undefined;
+    sessionId: string;
+    config: Record<string, unknown>;
+    selectWorkflow: SelectWorkflowFn;
+    defaultWorkflowId?: string;
+    applyResumeSelection?: ApplyResumeSelection;
+    frameworkAdapter?: FrameworkAdapter;
+}
+declare function tryPrepareResumeStream({ lastMessage, sessionId, config, selectWorkflow, defaultWorkflowId, applyResumeSelection, frameworkAdapter, }: TryResumeArgs): Promise<AsyncIterable<StreamChunk> | null>;
+
+interface RuntimeConfig {
+    session?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+interface ProcessChatArgs<Options> {
+    messages: ChatMessage[];
+    options?: Options | undefined;
+    sessionId?: string;
+    defaultWorkflowId?: string;
+    loadRuntimeConfig: (options?: Options) => RuntimeConfig | Promise<RuntimeConfig>;
+    selectWorkflow?: SelectWorkflowFn;
+    workflowRegistry?: WorkflowRegistry;
+    frameworkAdapter?: FrameworkAdapter;
+    getProvider: GetProviderFn;
+    memoryAdapter?: MemoryAdapter;
+    applyResumeSelection?: ApplyResumeSelection;
+}
+declare function processChat<Options = unknown>({ messages, options, sessionId, defaultWorkflowId, loadRuntimeConfig, selectWorkflow, workflowRegistry, frameworkAdapter, getProvider, memoryAdapter, applyResumeSelection, }: ProcessChatArgs<Options>): Promise<Response>;
+
+interface TransformOptions {
+    debug?: boolean;
+    emitStatus?: boolean;
+}
+/**
+ * Transforms LangGraph's astream_events into standardized UI chunks.
+ * Runtime emits (`message`, `structured_data`, `interrupt`, `transition`) are
+ * forwarded directly by the orchestrator, so this transformer only handles
+ * graph lifecycle + completion signals.
+ */
+declare function transformGraphStreamForUI(stream: AsyncIterable<StreamEvent>, options?: TransformOptions): AsyncGenerator<StreamChunk>;
+
+declare function extractLatestUserMessage(messages: ChatMessage[]): string;
+
+export { type Agent, type AgentMemoryConfig, type AgentProcessOptions, type AgentSessionConfig, type ApplyResumeSelection, ChatMessage, type ChatRequestBody, type CompiledGraphLike, type CreateAgentArgs, type OrchestrateArgs, type ProcessChatArgs, type ResumeMeta, type SaveMemoryFn, type SelectWorkflowFn, createAgent, createChatRouteHandler, extractLatestUserMessage, orchestrateGraphStream, parseChatRequestBody, parseResumeMeta, processChat, processChatRequestBody, transformGraphStreamForUI, tryPrepareResumeStream };