@jini-ai/daemon 0.5.4 → 0.6.1

package/dist/http/research.js

@@ -96,17 +96,11 @@ import { redactSecrets } from '@jini-ai/core';
  * generic-message substitution.
  */
 import { randomUUID } from 'node:crypto';
-import { validateBaseUrl } from '@jini-ai/agent-runtime';
+import { createTavilyResearchProvider } from './research-tavily.adapter.js';
 import { createApiError } from '@jini-ai/protocol';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
-const DEFAULT_TAVILY_BASE_URL = 'https://api.tavily.com';
-/** Tavily's own documented cap on `max_results` (see OD's `tavily.ts#TAVILY_MAX_RESULTS_LIMIT`). */
-const TAVILY_MAX_RESULTS_LIMIT = 20;
-const DEFAULT_MAX_SOURCES = 5;
-/** Matches OD's own `tavily.ts` timeout — see module doc. */
-const DEFAULT_TAVILY_TIMEOUT_MS = 30_000;
 /** Matches OD's real `research/index.ts#searchResearch` query cap — see module doc. */
 const MAX_QUERY_LENGTH = 1000;
 function defaultInternalErrorSink(context) {
@@ -123,8 +117,8 @@ function defaultInternalErrorSink(context) {
  * other provider name at parse time. A host that supports a second provider injects its own
  * `resolveCredentials` rather than reaching this function with a different id.
  */
-async function defaultResolveCredentials() {
-    const apiKey = process.env.TAVILY_API_KEY?.trim();
+async function defaultResolveCredentials({ env }) {
+    const apiKey = env.TAVILY_API_KEY?.trim();
     return apiKey ? { apiKey } : {};
 }
 function isRecord(value) {
@@ -138,17 +132,17 @@ function nonEmptyString(value) {
  * doc). OD only inspects `providers[0]` and treats a non-array `providers` value as absent rather
  * than rejecting it; this mirrors both.
  */
-function validateRequestedProvider(rawProviders) {
+function validateRequestedProvider(rawProviders, providerId) {
     if (!Array.isArray(rawProviders))
         return ok({ value: null });
     const filtered = rawProviders.filter((p) => typeof p === 'string' && p.length > 0);
     const requested = filtered[0];
-    if (requested !== undefined && requested !== 'tavily') {
-        return err({ error: validationError({ message: `provider "${requested}" is not supported — only "tavily" is available` }) });
+    if (requested !== undefined && requested !== providerId) {
+        return err({ error: validationError({ message: `provider "${requested}" is not supported — only "${providerId}" is available` }) });
     }
     return ok({ value: null });
 }
-function parseResearchSearch(input) {
+function parseResearchSearch(input, providerId = 'tavily') {
     if (!isRecord(input.body))
         return err({ error: validationError({ message: 'body must be a JSON object' }) });
     const rawQuery = nonEmptyString(input.body.query);
@@ -159,106 +153,11 @@ function parseResearchSearch(input) {
     if (maxSources !== undefined && (typeof maxSources !== 'number' || !Number.isFinite(maxSources) || maxSources <= 0)) {
         return err({ error: validationError({ message: 'maxSources must be a positive number when provided' }) });
     }
-    const providerCheck = validateRequestedProvider(input.body.providers);
+    const providerCheck = validateRequestedProvider(input.body.providers, providerId);
     if (!providerCheck.ok)
         return providerCheck;
     return ok({ value: { query, ...(maxSources !== undefined ? { maxSources: maxSources } : {}) } });
 }
-/**
- * Calls Tavily's real `POST /search` endpoint directly — see module doc for the port's exact
- * scope/provenance. Throws (never a `Result`) on any failure; the route handler below is the one
- * place that converts a thrown error into the package's SEC-005 response shape.
- *
- * `apiKey` is a separate, non-optional parameter rather than being read off `credentials`, so the
- * "credential is present" invariant is carried by the type system instead of by a runtime guard.
- * This function used to take only `credentials` and re-check `credentials.apiKey` itself, but the
- * sole caller below already returns `NOT_CONFIGURED` before it ever gets here — the check was
- * unreachable by construction, so it is now expressed as a required argument instead of dead code.
- * `credentials` is still passed for its optional transport config (`baseUrl`).
- */
-async function tavilySearch(apiKey, credentials, request) {
-    const baseUrl = credentials.baseUrl ?? DEFAULT_TAVILY_BASE_URL;
-    const baseUrlCheck = validateBaseUrl({ baseUrl });
-    if (baseUrlCheck.error) {
-        throw new Error(baseUrlCheck.error);
-    }
-    const base = baseUrl.replace(/\/+$/, '');
-    // Floor before clamping, matching OD's real `clampMaxSources` — see module doc. Without the
-    // floor, a fractional `maxSources` (e.g. `2.7`, or `0.5` before the `Math.max(1, ...)` floor
-    // below) would forward a non-integer `max_results` straight to Tavily's real API.
-    const maxResults = Math.max(1, Math.min(Math.floor(request.maxSources ?? DEFAULT_MAX_SOURCES), TAVILY_MAX_RESULTS_LIMIT));
-    const body = {
-        query: request.query,
-        search_depth: 'basic',
-        max_results: maxResults,
-        include_answer: true,
-        include_raw_content: false,
-    };
-    // The timeout must stay armed for the full operation, not just until `fetch` resolves —
-    // `fetch` resolves as soon as response headers arrive, before the body is read. A round-2
-    // external audit caught (and locally reproduced) an earlier version of this fix that cleared
-    // the timer right after `fetch` resolved, leaving `response.text()`/`response.json()` below
-    // completely unbounded against a server that sends headers promptly and then stalls the body.
-    //
-    // `TavilyHttpError` marks an error already redacted and formatted by the `!response.ok` branch
-    // below, so the outer catch can rethrow it verbatim instead of wrapping it a second time (which
-    // would otherwise produce a "Tavily request failed: Tavily 429: ..." double-prefixed message).
-    class TavilyHttpError extends Error {
-    }
-    const timeoutController = new AbortController();
-    const timeoutHandle = setTimeout(() => timeoutController.abort(), DEFAULT_TAVILY_TIMEOUT_MS);
-    // Assigned in the `try` and returned *after* the `finally`, rather than returned from inside the
-    // `try`. Both forms behave identically, but a return-through-`finally` compiles to three copies of
-    // the `finally` body (normal completion, return, throw) and one of those is unreachable here — the
-    // `try` cannot fall off its end and the `catch` always throws. Falling through to a single return
-    // keeps the cleanup path honestly measurable instead of permanently one-third uncovered.
-    let output;
-    try {
-        const response = await fetch(`${base}/search`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
-            body: JSON.stringify(body),
-            signal: timeoutController.signal,
-        });
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            throw new TavilyHttpError(redactSecrets({ input: `Tavily ${response.status}: ${text.slice(0, 200) || 'no body'}` }, { exactSecrets: [apiKey] }));
-        }
-        const json = (await response.json());
-        const answer = typeof json.answer === 'string' ? json.answer : '';
-        const rawResults = Array.isArray(json.results) ? json.results : [];
-        const sources = [];
-        for (const raw of rawResults) {
-            const url = typeof raw.url === 'string' ? raw.url : '';
-            if (!url)
-                continue;
-            const publishedAt = typeof raw.published_date === 'string' && raw.published_date.trim() ? raw.published_date.trim() : undefined;
-            sources.push({
-                title: typeof raw.title === 'string' && raw.title.trim() ? raw.title.trim() : url,
-                url,
-                snippet: typeof raw.content === 'string' ? raw.content.trim().slice(0, 800) : '',
-                provider: 'tavily',
-                ...(publishedAt ? { publishedAt } : {}),
-            });
-        }
-        output = { answer, sources };
-    }
-    catch (error) {
-        if (!timeoutController.signal.aborted && error instanceof TavilyHttpError) {
-            throw error;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(redactSecrets({
-            input: timeoutController.signal.aborted
-                ? `Tavily request timed out after ${DEFAULT_TAVILY_TIMEOUT_MS}ms`
-                : `Tavily request failed: ${message}`,
-        }, { exactSecrets: [apiKey] }));
-    }
-    finally {
-        clearTimeout(timeoutHandle);
-    }
-    return output;
-}
 /** Ported verbatim from OD's real `research/index.ts#synthesizeFallbackSummary` — see module doc. Used when Tavily returns no `answer` text so the caller still gets a usable `summary`. */
 function synthesizeFallbackSummary(sources) {
     const lead = sources
@@ -267,49 +166,65 @@ function synthesizeFallbackSummary(sources) {
         .join('\n');
     return `(No provider summary; top snippets follow.)\n${lead}`;
 }
-export const researchSearchRoute = defineJsonRoute({
-    method: 'post', path: '/api/research/search', parse: parseResearchSearch, handle: async ({ input: request, deps }) => {
-        const resolveCredentials = deps.resolveCredentials ?? defaultResolveCredentials;
-        const onInternalError = deps.onInternalError ?? defaultInternalErrorSink;
-        let credentials;
-        try {
-            credentials = await resolveCredentials({ providerId: 'tavily' });
-        }
-        catch (error) {
-            const correlationId = randomUUID();
-            onInternalError({ correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
-        }
-        const apiKey = credentials.apiKey;
-        if (!apiKey) {
-            return err({ error: createApiError({ code: 'NOT_CONFIGURED', message: 'tavily provider not configured' }) });
-        }
-        try {
-            const raw = await tavilySearch(apiKey, credentials, request);
-            // Matches OD's real `NO_RESEARCH_SOURCES` (404) — see module doc. Zero usable sources is a
-            // failure, not an empty success, even when the upstream Tavily call itself succeeded.
-            if (raw.sources.length === 0) {
-                return err({ error: createApiError({ code: 'NOT_FOUND', message: 'no sources found' }) });
+/** Builds one route over a host-selected provider, preserving the default Tavily validation contract. */
+export function createResearchSearchRoute({ provider }, _optional = {}) {
+    const providerId = provider?.id ?? 'tavily';
+    return defineJsonRoute({
+        method: 'post', path: '/api/research/search', parse: (input) => parseResearchSearch(input, providerId), handle: async ({ input: request, deps }) => {
+            const selectedProvider = provider ?? deps.provider ?? createTavilyResearchProvider({}, deps.fetch ? { fetch: deps.fetch } : {});
+            const resolveCredentials = deps.resolveCredentials ?? (() => selectedProvider.id === 'tavily' ? defaultResolveCredentials({ env: deps.env ?? process.env }) : Promise.resolve({}));
+            const onInternalError = deps.onInternalError ?? defaultInternalErrorSink;
+            let credentials;
+            try {
+                credentials = await resolveCredentials({ providerId: selectedProvider.id });
+            }
+            catch (error) {
+                const correlationId = randomUUID();
+                onInternalError({ correlationId, error });
+                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            }
+            const apiKey = credentials.apiKey;
+            if (!apiKey) {
+                return err({ error: createApiError({ code: 'NOT_CONFIGURED', message: `${selectedProvider.id} provider not configured` }) });
+            }
+            try {
+                const raw = await selectedProvider.search({ apiKey, credentials, request }, {});
+                // Matches OD's real `NO_RESEARCH_SOURCES` (404) — see module doc. Zero usable sources is a
+                // failure, not an empty success, even when the upstream Tavily call itself succeeded.
+                if (raw.sources.length === 0) {
+                    return err({ error: createApiError({ code: 'NOT_FOUND', message: 'no sources found' }) });
+                }
+                const result = {
+                    query: request.query,
+                    summary: raw.answer || synthesizeFallbackSummary(raw.sources),
+                    sources: raw.sources,
+                    provider: selectedProvider.id,
+                    depth: 'shallow',
+                    fetchedAt: Date.now(),
+                };
+                return ok({ value: result });
+            }
+            catch (error) {
+                const correlationId = randomUUID();
+                // A host provider can throw transport text too; keep its configured key out of the sink.
+                const safeMessage = redactSecrets({ input: error instanceof Error ? error.message : String(error) }, { exactSecrets: [apiKey] });
+                const safeError = new Error(safeMessage);
+                if (error instanceof Error) {
+                    safeError.name = redactSecrets({ input: error.name }, { exactSecrets: [apiKey] });
+                    if (error.stack === undefined)
+                        delete safeError.stack;
+                    else
+                        safeError.stack = redactSecrets({ input: error.stack }, { exactSecrets: [apiKey] });
+                }
+                onInternalError({ correlationId, error: safeError });
+                return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
             }
-            const result = {
-                query: request.query,
-                summary: raw.answer || synthesizeFallbackSummary(raw.sources),
-                sources: raw.sources,
-                provider: 'tavily',
-                depth: 'shallow',
-                fetchedAt: Date.now(),
-            };
-            return ok({ value: result });
-        }
-        catch (error) {
-            const correlationId = randomUUID();
-            onInternalError({ correlationId, error });
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
         }
-    }
-}, { requireSameOrigin: true });
+    }, { requireSameOrigin: true });
+}
+export const researchSearchRoute = createResearchSearchRoute({});
 /** Mounts `POST /api/research/search` on `app`. A pack's `http(app, services)` calls this directly. */
 export function registerResearchRoutes({ app, deps, adapter }, _optional = {}) {
-    mountJsonRoute({ app, spec: researchSearchRoute, deps, adapter });
+    mountJsonRoute({ app, spec: deps.provider ? createResearchSearchRoute({ provider: deps.provider }) : researchSearchRoute, deps, adapter });
 }
 //# sourceMappingURL=research.js.map

package/dist/http/route-manifest.js

@@ -31,7 +31,7 @@
 import { agentListRoute, agentRescanRoute } from './agents.js';
 import { delegatedToolExecuteRoute } from './delegated-tools.js';
 import { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, versionInfoRoute, } from './health.js';
-import { RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+import { RUN_EVENTS_ROUTE_PATH, runCancelRoute, runMessageRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
 import { toolCatalogDescribeRoute, toolCatalogSearchRoute } from './tool-catalog.js';
 /**
  * Projects route specs onto `RouteRegistration`s, upper-casing the method so entries compare directly
@@ -52,7 +52,7 @@ function fromSpecs(...specs) {
 export const JINI_ROUTE_MANIFEST = {
     health: fromSpecs(healthRoute, apiHealthRoute, readyRoute, apiReadyRoute, versionInfoRoute, apiVersionInfoRoute),
     runs: [
-        ...fromSpecs(runStartRoute, runListRoute, runStatusRoute, runCancelRoute),
+        ...fromSpecs(runStartRoute, runListRoute, runStatusRoute, runCancelRoute, runMessageRoute),
         // Registered with a bare `app.get` rather than a route spec (by `registerRunRoutes` itself), so
         // it contributes its exported path constant instead of a copied literal.
         { method: 'GET', path: RUN_EVENTS_ROUTE_PATH },

package/dist/http/runs.d.ts

@@ -1,6 +1,6 @@
 import type { Express } from 'express';
 import { type RunStatus } from '@jini-ai/protocol';
-import type { RunLifecycle } from '../index.js';
+import type { RunLifecycle, UserMessageDelivery } from '../index.js';
 import { type AdapterContext } from '@jini-ai/http-kit';
 import type { ServerResponse } from 'node:http';
 /**
@@ -34,6 +34,15 @@ export interface RunHttpDeps {
     readonly onStarted?: RunStartHandler;
     /** Host-owned sink for the real exception behind a generic `INTERNAL_ERROR` response (SEC-005). Defaults to `console.error`. */
     readonly onInternalError?: (context: RunInternalErrorContext) => void;
+    /**
+     * Delivers a message the human sent mid-run into that run's live agent — a host passes its
+     * `AgentExecutor.sendUserMessage`. Omitted, every such message reports `'unsupported'`, so the
+     * client falls back to interrupting the run and sending the text as the next turn.
+     */
+    readonly deliverUserMessage?: (input: {
+        readonly runId: string;
+        readonly text: string;
+    }) => UserMessageDelivery | Promise<UserMessageDelivery>;
 }
 export interface RunStartResponse {
     readonly run: RunStatus;
@@ -45,6 +54,15 @@ export interface RunStatusResponse {
 export interface RunCancelResponse {
     readonly run: RunStatus;
 }
+export interface RunMessageRequest {
+    readonly runId: string;
+    readonly text: string;
+}
+export interface RunMessageResponse {
+    readonly delivery: 'delivered';
+}
+/** Ceiling on one mid-run message, matching what a person can reasonably type or paste into a composer. */
+export declare const RUN_MESSAGE_MAX_CHARS = 100000;
 export interface RunListResponse {
     readonly runs: readonly RunStatus[];
 }
@@ -58,6 +76,13 @@ export declare const runCancelRoute: import("@jini-ai/http-kit").JsonRouteSpec<{
     runId: string;
     reason?: string;
 }, RunCancelResponse, RunHttpDeps, undefined>;
+/**
+ * `POST /api/runs/:runId/messages` — a message the human sent while the run is going. `202` when it
+ * reached the live agent; `409 CONFLICT` with `details.delivery` (`'unsupported'` or
+ * `'not-running'`) when it did not, which tells the client whether to interrupt the run and send the
+ * text as the next turn, or simply send it next because the run is already ending.
+ */
+export declare const runMessageRoute: import("@jini-ai/http-kit").JsonRouteSpec<RunMessageRequest, RunMessageResponse, RunHttpDeps, undefined>;
 /**
  * The core of `GET /api/runs/:runId/events` — canonical events as SSE, with Last-Event-ID
  * reconnect support. Takes `runId`/`afterCursor` already resolved by the caller. `res` is typed
@@ -82,7 +107,7 @@ export declare function registerRunEventStream({ app, deps }: {
     readonly app: Express;
     readonly deps: RunHttpDeps;
 }, _optional?: Record<string, never>): void;
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport. */
+/** Mounts create/status/cancel/message JSON endpoints and the SSE event stream as one run transport. */
 export declare function registerRunRoutes({ app, deps, adapter }: {
     readonly app: Express;
     readonly deps: RunHttpDeps;

package/dist/http/runs.js

@@ -57,6 +57,23 @@ function parseRunCreate(input) {
         }
     });
 }
+/** Ceiling on one mid-run message, matching what a person can reasonably type or paste into a composer. */
+export const RUN_MESSAGE_MAX_CHARS = 100_000;
+function parseRunMessage(input) {
+    const parsedRunId = parseRunId(input);
+    if (!parsedRunId.ok)
+        return parsedRunId;
+    if (!isRecord(input.body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const text = optionalString(input.body, 'text');
+    if (text === undefined || text === null) {
+        return err({ error: validationError({ message: 'text must be a non-empty string' }, { issues: [{ path: 'text', message: 'required non-empty string' }] }) });
+    }
+    if (text.length > RUN_MESSAGE_MAX_CHARS) {
+        return err({ error: validationError({ message: `text must be at most ${RUN_MESSAGE_MAX_CHARS} characters` }, { issues: [{ path: 'text', message: 'too long' }] }) });
+    }
+    return ok({ value: { runId: parsedRunId.value, text } });
+}
 function parseRunList(input) {
     const value = input.query.contextRef;
     if (value === undefined)
@@ -121,6 +138,23 @@ export const runCancelRoute = defineJsonRoute({
         return ok({ value: { run: await deps.lifecycle.cancel(input) } });
     }
 }, { requireSameOrigin: true });
+/**
+ * `POST /api/runs/:runId/messages` — a message the human sent while the run is going. `202` when it
+ * reached the live agent; `409 CONFLICT` with `details.delivery` (`'unsupported'` or
+ * `'not-running'`) when it did not, which tells the client whether to interrupt the run and send the
+ * text as the next turn, or simply send it next because the run is already ending.
+ */
+export const runMessageRoute = defineJsonRoute({
+    method: 'post', path: '/api/runs/:runId/messages', parse: parseRunMessage, handle: async ({ input, deps }) => {
+        const run = await deps.lifecycle.get({ runId: input.runId });
+        if (run === undefined)
+            return err({ error: createApiError({ code: 'NOT_FOUND', message: `run "${input.runId}" was not found` }) });
+        const delivery = deps.deliverUserMessage ? await deps.deliverUserMessage({ runId: input.runId, text: input.text }) : 'unsupported';
+        if (delivery === 'delivered')
+            return ok({ value: { delivery } });
+        return err({ error: createApiError({ code: 'CONFLICT', message: `run "${input.runId}" did not take the message` }, { details: { delivery } }) });
+    }
+}, { requireSameOrigin: true, successStatus: 202 });
 function sendStreamFailure(res, kind) {
     if (kind.kind === 'unknown-run') {
         sendRawApiError({ res, status: 404, error: createApiError({ code: 'NOT_FOUND', message: 'run was not found' }) });
@@ -210,12 +244,13 @@ export function registerRunEventStream({ app, deps }, _optional = {}) {
         await handleRunEventStreamRequest({ res, runId, afterCursor: requestedAfterCursor(req), deps });
     });
 }
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport. */
+/** Mounts create/status/cancel/message JSON endpoints and the SSE event stream as one run transport. */
 export function registerRunRoutes({ app, deps, adapter }, _optional = {}) {
     mountJsonRoute({ app, spec: runStartRoute, deps, adapter });
     mountJsonRoute({ app, spec: runListRoute, deps, adapter });
     mountJsonRoute({ app, spec: runStatusRoute, deps, adapter });
     mountJsonRoute({ app, spec: runCancelRoute, deps, adapter });
+    mountJsonRoute({ app, spec: runMessageRoute, deps, adapter });
     registerRunEventStream({ app, deps });
 }
 //# sourceMappingURL=runs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "description": "The stateful agent daemon runtime: run lifecycle, durable event-log port, the tool-execution boundary, agent executor, terminal sessions, and routines.",
   "license": "Apache-2.0",
   "repository": {
@@ -139,29 +139,29 @@
     "@types/pg": "8.23.1",
     "express": "^4.21.0",
     "@types/express": "^4.17.21",
-    "@jini-ai/chat": "0.5.5",
-    "@jini-ai/http-kit": "0.4.1",
-    "@jini-ai/db": "0.3.1",
-    "@jini-ai/agent-runtime": "^0.4.2",
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/protocol": "^0.4.2",
-    "@jini-ai/platform": "^0.5.2"
+    "@jini-ai/chat": "0.5.8",
+    "@jini-ai/db": "0.3.2",
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/protocol": "^0.4.4",
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/http-kit": "0.4.1"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/protocol": "^0.4.2"
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "peerDependencies": {
     "node-pty": "^1.1.0",
-    "@jini-ai/db": "^0.2.0 || ^0.3.0",
+    "@jini-ai/db": "^0.3.2",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",
     "pg": "^8.23.0",
     "@jini-ai/http-kit": "^0.4.0",
     "express": "^4.21.0",
-    "@jini-ai/agent-runtime": "^0.4.1",
-    "@jini-ai/platform": "^0.5.1"
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/platform": "^0.5.3"
   },
   "peerDependenciesMeta": {
     "node-pty": {