nexus-agentd 0.2.5 → 0.3.0

package/dist/sse-writer.d.ts

@@ -0,0 +1,7 @@
+import type { ServerResponse } from 'node:http';
+/** A false write already accepted the chunk. Queue later chunks until drain,
+ * with both a byte ceiling and a deadline independent of socket activity. */
+export declare function createSseWriter(response: ServerResponse, close: () => void, maxBytes?: number, drainMs?: number): {
+    write(chunk: string): boolean;
+    stop: () => void;
+};

package/dist/sse-writer.js

@@ -0,0 +1,60 @@
+/** A false write already accepted the chunk. Queue later chunks until drain,
+ * with both a byte ceiling and a deadline independent of socket activity. */
+export function createSseWriter(response, close, maxBytes = 512 * 1024, drainMs = 5_000) {
+    let stopped = false;
+    let blocked = false;
+    let queuedBytes = 0;
+    const queue = [];
+    let deadline;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearTimeout(deadline);
+        response.off('drain', drain);
+        queue.length = 0;
+        queuedBytes = 0;
+    };
+    const fail = () => { stop(); close(); };
+    const send = (chunk) => {
+        try {
+            if (!response.write(chunk)) {
+                blocked = true;
+                deadline = setTimeout(fail, drainMs);
+                deadline.unref?.();
+            }
+        }
+        catch {
+            fail();
+        }
+    };
+    const drain = () => {
+        clearTimeout(deadline);
+        blocked = false;
+        while (!stopped && !blocked && queue.length) {
+            const chunk = queue.shift();
+            queuedBytes -= Buffer.byteLength(chunk);
+            send(chunk);
+        }
+    };
+    response.on('drain', drain);
+    return {
+        write(chunk) {
+            if (stopped)
+                return false;
+            const size = Buffer.byteLength(chunk);
+            if (response.destroyed || response.writableEnded || size + queuedBytes + response.writableLength > maxBytes) {
+                fail();
+                return false;
+            }
+            if (blocked) {
+                queue.push(chunk);
+                queuedBytes += size;
+            }
+            else
+                send(chunk);
+            return !stopped;
+        },
+        stop
+    };
+}

package/dist/types.d.ts

@@ -14,7 +14,7 @@ export interface AgentdTurnCompletion extends AgentdTurnCompletionProof {
     artifactCount: number;
     completedAt: number;
 }
-export declare const agentdDriverKinds: readonly ["opencode", "claude", "codex", "pi", "openclaw", "hermes"];
+export declare const agentdDriverKinds: readonly ["stdio", "opencode", "claude", "codex", "pi", "openclaw", "hermes"];
 export type AgentdDriverKind = (typeof agentdDriverKinds)[number];
 export interface AgentdDriverConfig {
     protocol?: 'acp';
@@ -25,6 +25,8 @@ export interface AgentdDriverConfig {
     workspace?: string;
     command?: string;
     args?: string[];
+    /** Arguments used by a command availability probe. */
+    probeArgs?: string[];
     inheritEnv?: string[];
     env?: Record<string, string>;
     permissionPolicy?: PermissionPolicy;
@@ -48,6 +50,10 @@ export interface AgentdA2AConfig {
         headerName?: string;
     };
     timeoutMs?: number;
+    /** Maximum time allowed for one logical A2A task. Inherits global promptTimeoutMs when omitted. */
+    taskTimeoutMs?: number;
+    /** Maximum time between bytes/events while reading an A2A stream. Inherits timeoutMs when omitted. */
+    streamIdleTimeoutMs?: number;
 }
 export type AgentdAgentConfig = AgentdDriverConfig | AgentdA2AConfig;
 export interface AgentdApiKeyScope {
@@ -87,6 +93,28 @@ export interface AgentdConfig {
     maxConnections?: number;
     adminSessionTtlMs?: number;
     secureAdminCookies?: boolean;
+    /** Exact browser origins for named LAN hosts or TLS reverse proxies. */
+    publicOrigins?: string[];
+    /** Per-client budgets; changes require a restart. */
+    quotas?: {
+        maxSessionsPerKey: number;
+        maxRunningRunsPerKey: number;
+        maxSsePerKey: number;
+        maxUploadBytesPerKey: number;
+    };
+    /** Persisted task metadata and output retention; active runs are protected. */
+    history?: {
+        maxRuns: number;
+        retentionDays: number;
+        maxBytes: number;
+    };
+    /** Persisted artifact payload retention and queue limits. */
+    artifacts?: {
+        retentionDays: number;
+        maxBytes: number;
+        maxArtifactBytes: number;
+        maxQueuedBytes: number;
+    };
     agents: Record<string, AgentdAgentConfig>;
 }
 export interface AgentdAgentView {
@@ -122,6 +150,8 @@ export interface AgentdAgentConfigView {
         configured: boolean;
     };
     timeoutMs?: number;
+    taskTimeoutMs?: number;
+    streamIdleTimeoutMs?: number;
 }
 export interface AgentdControlPlaneView {
     workspaceRoots: string[];
@@ -235,16 +265,20 @@ export interface AgentdRunArtifactView {
     filename?: string;
     mediaType?: string;
     metadata?: Record<string, unknown>;
+    size?: number;
+    downloadable?: boolean;
+    storageStatus?: 'pending' | 'available' | 'metadata_only' | 'expired' | 'evicted' | 'failed';
 }
 export interface AgentdRunView {
     id: string;
     sessionId: string;
+    retryOfRunId?: string;
     agentId: string;
     agentName: string;
     protocol: AgentdProtocol;
     workspace?: string;
     protocolSessionId?: string;
-    task: string;
+    taskPreview: string;
     taskTruncated?: boolean;
     state: AgentdSessionState;
     progress: AgentdRunProgress;
@@ -259,8 +293,16 @@ export interface AgentdRunView {
     durationMs?: number;
 }
 export interface AgentdRunDetail extends AgentdRunView {
+    task: string;
     output?: string;
     artifacts: AgentdRunArtifactView[];
+    controls?: AgentdRunControls;
+}
+export interface AgentdRunControls {
+    canCancel: boolean;
+    canRetry: boolean;
+    pendingRequest?: AgentdPendingRequest;
+    unavailableReason?: string;
 }
 export type AgentdEventType = 'session_state' | 'assistant_chunk' | 'thought_chunk' | 'plan' | 'tool_call' | 'tool_update' | 'terminal_output' | 'file_activity' | 'artifact' | 'permission_required' | 'input_required' | 'completed' | 'failed' | 'canceled';
 export interface AgentdEvent {

package/dist/types.js

@@ -1,4 +1,5 @@
 export const agentdDriverKinds = [
+    'stdio',
     'opencode',
     'claude',
     'codex',