@namzu/sdk 0.1.1

package/dist/vault/InMemoryCredentialVault.js

@@ -0,0 +1,49 @@
+import { generateCredentialId } from '../utils/id.js';
+import { getRootLogger } from '../utils/logger.js';
+export class InMemoryCredentialVault {
+    refs = new Map();
+    secrets = new Map();
+    log;
+    constructor() {
+        this.log = getRootLogger().child({ component: 'InMemoryCredentialVault' });
+    }
+    async store(tenantId, connectorId, label, auth) {
+        const id = generateCredentialId();
+        const ref = {
+            id,
+            connectorId,
+            tenantId,
+            label,
+            authType: auth.type,
+            createdAt: Date.now(),
+        };
+        this.refs.set(id, ref);
+        this.secrets.set(id, auth);
+        this.log.info(`Credential stored: ${id} (${label}) for tenant ${tenantId}`);
+        return ref;
+    }
+    async retrieve(credentialId) {
+        return this.secrets.get(credentialId);
+    }
+    async revoke(credentialId) {
+        const existed = this.refs.has(credentialId);
+        this.refs.delete(credentialId);
+        this.secrets.delete(credentialId);
+        if (existed) {
+            this.log.info(`Credential revoked: ${credentialId}`);
+        }
+        return existed;
+    }
+    async list(tenantId, connectorId) {
+        const results = [];
+        for (const ref of this.refs.values()) {
+            if (ref.tenantId !== tenantId)
+                continue;
+            if (connectorId && ref.connectorId !== connectorId)
+                continue;
+            results.push(ref);
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=InMemoryCredentialVault.js.map

package/dist/vault/InMemoryCredentialVault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryCredentialVault.js","sourceRoot":"","sources":["../../src/vault/InMemoryCredentialVault.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAe,MAAM,oBAAoB,CAAA;AAE/D,MAAM,OAAO,uBAAuB;IAC1B,IAAI,GAAqC,IAAI,GAAG,EAAE,CAAA;IAClD,OAAO,GAAkC,IAAI,GAAG,EAAE,CAAA;IAClD,GAAG,CAAQ;IAEnB;QACE,IAAI,CAAC,GAAG,GAAG,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,yBAAyB,EAAE,CAAC,CAAA;IAC5E,CAAC;IAED,KAAK,CAAC,KAAK,CACT,QAAkB,EAClB,WAAmB,EACnB,KAAa,EACb,IAAgB;QAEhB,MAAM,EAAE,GAAG,oBAAoB,EAAE,CAAA;QACjC,MAAM,GAAG,GAAkB;YACzB,EAAE;YACF,WAAW;YACX,QAAQ;YACR,KAAK;YACL,QAAQ,EAAE,IAAI,CAAC,IAAI;YACnB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAA;QAED,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAA;QACtB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,KAAK,gBAAgB,QAAQ,EAAE,CAAC,CAAA;QAC3E,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,YAA0B;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IACvC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,YAA0B;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;QAC3C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QAC9B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QACjC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,uBAAuB,YAAY,EAAE,CAAC,CAAA;QACtD,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAkB,EAAE,WAAoB;QACjD,MAAM,OAAO,GAAoB,EAAE,CAAA;QACnC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YACrC,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ;gBAAE,SAAQ;YACvC,IAAI,WAAW,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW;gBAAE,SAAQ;YAC5D,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACnB,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;CACF"}

package/dist/vault/index.d.ts

@@ -0,0 +1,2 @@
+export { InMemoryCredentialVault } from './InMemoryCredentialVault.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vault/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vault/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/vault/index.js

@@ -0,0 +1,2 @@
+export { InMemoryCredentialVault } from './InMemoryCredentialVault.js';
+//# sourceMappingURL=index.js.map

package/dist/vault/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/vault/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,EAAE,MAAoB,CAAA"}

package/dist/version.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const VERSION = pkg.version;
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AAC9C,MAAM,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAwB,CAAA;AAE7D,MAAM,CAAC,MAAM,OAAO,GAAW,GAAG,CAAC,OAAO,CAAA"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@namzu/sdk",
+  "version": "0.1.1",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "packageManager": "pnpm@10.33.0",
+  "homepage": "https://github.com/cogitave/namzu#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cogitave/namzu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cogitave/namzu/issues"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE.md",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --build --watch",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.700.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
+    "@opentelemetry/resources": "^1.30.0",
+    "@opentelemetry/sdk-metrics": "^1.30.0",
+    "@opentelemetry/sdk-node": "^0.57.0",
+    "@opentelemetry/sdk-trace-node": "^1.30.0",
+    "@opentelemetry/semantic-conventions": "^1.30.0",
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.17",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/agents/AbstractAgent.ts

@@ -0,0 +1,95 @@
+import type { AgentManager } from "../manager/agent/lifecycle.js";
+import type {
+	Agent,
+	AgentCapabilities,
+	AgentInput,
+	AgentMetadata,
+	AgentType,
+	BaseAgentConfig,
+	BaseAgentResult,
+} from "../types/agent/index.js";
+import { EMPTY_TOKEN_USAGE } from "../types/common/index.js";
+import type { RunId } from "../types/ids/index.js";
+import type {
+	RunEvent,
+	RunEventListener,
+} from "../types/run/index.js";
+import { ZERO_COST } from "../utils/cost.js";
+import { toErrorMessage } from "../utils/error.js";
+import { generateRunId } from "../utils/id.js";
+import { type Logger, getRootLogger } from "../utils/logger.js";
+
+export abstract class AbstractAgent<
+	TConfig extends BaseAgentConfig = BaseAgentConfig,
+	TResult extends BaseAgentResult = BaseAgentResult,
+> implements Agent<TConfig, TResult>
+{
+	abstract readonly type: AgentType;
+	readonly metadata: AgentMetadata;
+	protected log: Logger;
+	protected abortController: AbortController;
+
+	protected agentManager?: AgentManager;
+
+	protected currentRunId?: RunId;
+
+	constructor(metadata: AgentMetadata) {
+		this.metadata = metadata;
+		this.abortController = new AbortController();
+		this.log = getRootLogger().child({
+			component: `Agent:${metadata.type}`,
+			agentId: metadata.id,
+		});
+	}
+
+	abstract run(
+		input: AgentInput,
+		config: TConfig,
+		listener?: RunEventListener,
+	): Promise<TResult>;
+
+	async cancel(): Promise<void> {
+		this.abortController.abort();
+
+		if (this.agentManager && this.currentRunId) {
+			this.agentManager.cancelAll(this.currentRunId);
+		}
+	}
+
+	getCapabilities(): AgentCapabilities {
+		return this.metadata.capabilities;
+	}
+
+	protected createRunId(): RunId {
+		return generateRunId();
+	}
+
+	protected createEmptyResult(
+		runId: RunId,
+		startTime: number,
+	): BaseAgentResult {
+		return {
+			runId,
+			status: "idle",
+			usage: { ...EMPTY_TOKEN_USAGE },
+			cost: { ...ZERO_COST },
+			iterations: 0,
+			durationMs: Date.now() - startTime,
+			messages: [],
+		};
+	}
+
+	protected async emitEvent(
+		event: RunEvent,
+		listener?: RunEventListener,
+	): Promise<void> {
+		if (!listener) return;
+		try {
+			await listener(event);
+		} catch (err) {
+			this.log.error("Event listener error", {
+				error: toErrorMessage(err),
+			});
+		}
+	}
+}

package/src/agents/PipelineAgent.ts

@@ -0,0 +1,165 @@
+import type { RunEventListener } from '../types/run/index.js'
+import type {
+  PipelineAgentConfig,
+  PipelineAgentResult,
+  PipelineStepResult,
+  AgentInput,
+  AgentMetadata,
+  StepContext,
+} from '../types/agent/index.js'
+import { AbstractAgent } from './AbstractAgent.js'
+import { EMPTY_TOKEN_USAGE } from '../types/common/index.js'
+import { ZERO_COST } from '../utils/cost.js'
+import { toErrorMessage } from '../utils/error.js'
+
+export class PipelineAgent extends AbstractAgent<PipelineAgentConfig, PipelineAgentResult> {
+  readonly type = 'pipeline' as const
+
+  constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
+    super({
+      ...metadata,
+      type: 'pipeline',
+      capabilities: {
+        supportsTools: false,
+        supportsStreaming: false,
+        supportsConcurrency: false,
+        supportsSubAgents: false,
+      },
+    })
+  }
+
+  async run(
+    input: AgentInput,
+    config: PipelineAgentConfig,
+    listener?: RunEventListener,
+  ): Promise<PipelineAgentResult> {
+    const startTime = Date.now()
+    const runId = this.createRunId()
+    const stepResults: PipelineStepResult[] = []
+    const previousResults = new Map<string, unknown>()
+    let completedSteps = 0
+
+    await this.emitEvent({ type: 'run_started', runId }, listener)
+
+    let currentInput: unknown = input.messages
+      .filter((m) => m.role === 'user')
+      .map((m) => m.content)
+      .filter((c): c is string => c !== null)
+      .join('\n')
+
+    for (let i = 0; i < config.steps.length; i++) {
+      const step = config.steps[i]
+      const stepStart = Date.now()
+
+      if (this.abortController.signal.aborted) {
+        stepResults.push({
+          stepName: step.name,
+          status: 'skipped',
+          durationMs: 0,
+        })
+        continue
+      }
+
+      await this.emitEvent(
+        { type: 'iteration_started', runId, iteration: i + 1 },
+        listener,
+      )
+
+      const context: StepContext = {
+        runId,
+        stepIndex: i,
+        totalSteps: config.steps.length,
+        previousResults,
+        provider: config.provider,
+        signal: this.abortController.signal,
+        env: config.env ?? {},
+      }
+
+      try {
+        if (step.validate && !step.validate(currentInput)) {
+          throw new Error(`Validation failed for step "${step.name}"`)
+        }
+
+        const output = await step.execute(currentInput, context)
+        previousResults.set(step.name, output)
+        currentInput = output
+        completedSteps++
+
+        stepResults.push({
+          stepName: step.name,
+          status: 'completed',
+          output,
+          durationMs: Date.now() - stepStart,
+        })
+      } catch (err) {
+        const errorMsg = toErrorMessage(err)
+
+        stepResults.push({
+          stepName: step.name,
+          status: 'failed',
+          error: errorMsg,
+          durationMs: Date.now() - stepStart,
+        })
+
+        if (step.rollback) {
+          try {
+            await step.rollback(currentInput, context)
+          } catch (rollbackErr) {
+            this.log.error(`Rollback failed for step "${step.name}"`, {
+              error: toErrorMessage(rollbackErr),
+            })
+          }
+        }
+
+        if (!config.continueOnError) {
+          await this.emitEvent(
+            { type: 'run_failed', runId, error: errorMsg },
+            listener,
+          )
+
+          return {
+            runId,
+            status: 'failed',
+            stopReason: 'error',
+            usage: { ...EMPTY_TOKEN_USAGE },
+            cost: { ...ZERO_COST },
+            iterations: i + 1,
+            durationMs: Date.now() - startTime,
+            messages: input.messages,
+            lastError: errorMsg,
+            stepResults,
+            completedSteps,
+            totalSteps: config.steps.length,
+          }
+        }
+      }
+    }
+
+    const finalStatus = completedSteps === config.steps.length ? 'completed' : 'failed'
+    const lastOutput = stepResults[stepResults.length - 1]?.output
+
+    await this.emitEvent(
+      {
+        type: 'run_completed',
+        runId,
+        result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
+      },
+      listener,
+    )
+
+    return {
+      runId,
+      status: finalStatus,
+      stopReason: 'end_turn',
+      usage: { ...EMPTY_TOKEN_USAGE },
+      cost: { ...ZERO_COST },
+      iterations: config.steps.length,
+      durationMs: Date.now() - startTime,
+      messages: input.messages,
+      result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
+      stepResults,
+      completedSteps,
+      totalSteps: config.steps.length,
+    }
+  }
+}

package/src/agents/ReactiveAgent.ts

@@ -0,0 +1,97 @@
+import type { RunEventListener } from '../types/run/index.js'
+import type { AssistantMessage } from '../types/message/index.js'
+import type {
+  ReactiveAgentConfig,
+  ReactiveAgentResult,
+  AgentInput,
+  AgentMetadata,
+} from '../types/agent/index.js'
+import { AbstractAgent } from './AbstractAgent.js'
+import { drainQuery } from '../runtime/query/index.js'
+
+export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAgentResult> {
+  readonly type = 'reactive' as const
+
+  constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
+    super({
+      ...metadata,
+      type: 'reactive',
+      capabilities: {
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsConcurrency: false,
+        supportsSubAgents: false,
+      },
+    })
+  }
+
+  async run(
+    input: AgentInput,
+    config: ReactiveAgentConfig,
+    listener?: RunEventListener,
+  ): Promise<ReactiveAgentResult> {
+    const startTime = Date.now()
+
+    const session = await drainQuery(
+      {
+        systemPrompt: config.systemPrompt,
+        persona: config.persona,
+        skills: config.skills,
+        basePrompt: config.basePrompt,
+        provider: config.provider,
+        tools: config.tools,
+        sessionConfig: {
+          model: config.model,
+          tokenBudget: config.tokenBudget,
+          timeoutMs: config.timeoutMs,
+          maxIterations: config.maxIterations,
+          temperature: config.temperature,
+          maxResponseTokens: config.maxResponseTokens,
+          costLimitUsd: config.costLimitUsd,
+          permissionMode: config.permissionMode,
+          env: config.env,
+        },
+        agentId: this.metadata.id,
+        agentName: this.metadata.name,
+        workingDirectory: input.workingDirectory,
+        threadId: config.threadId!,
+        parentRunId: config.parentRunId,
+        depth: config.depth,
+        contextLevel: config.contextLevel,
+        messages: input.messages,
+        signal: input.signal,
+        taskStore: input.taskStore,
+        runtimeToolOverrides: input.runtimeToolOverrides,
+      },
+      listener,
+    )
+
+    let toolCallCount = 0
+    for (const msg of session.messages) {
+      if (msg.role === 'assistant') {
+        const assistantMsg = msg as AssistantMessage
+        if (assistantMsg.toolCalls) {
+          toolCallCount += assistantMsg.toolCalls.length
+        }
+      }
+    }
+
+    return {
+      runId: session.id,
+      status: session.status,
+      stopReason: session.stopReason,
+      usage: session.tokenUsage,
+      cost: session.costInfo,
+      iterations: session.currentIteration,
+      durationMs: Date.now() - startTime,
+      messages: session.messages,
+      result: session.result,
+      lastError: session.lastError,
+      toolCallCount,
+    }
+  }
+
+  async cancel(): Promise<void> {
+    this.abortController.abort()
+  }
+}