@namzu/sdk 0.1.5-rc.2 → 0.1.5

package/src/store/task/__tests__/disk-concurrency.test.ts

@@ -0,0 +1,118 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { RunId } from '../../../types/ids/index.js'
+import { generateRunId } from '../../../utils/id.js'
+import { DiskTaskStore } from '../disk.js'
+
+describe('DiskTaskStore — concurrency regressions', () => {
+	let baseDir: string
+	let runId: RunId
+	let store: DiskTaskStore
+
+	beforeEach(() => {
+		baseDir = mkdtempSync(join(tmpdir(), 'namzu-task-concurrency-'))
+		runId = generateRunId()
+		store = new DiskTaskStore({ baseDir, defaultRunId: runId })
+	})
+
+	afterEach(() => {
+		rmSync(baseDir, { recursive: true, force: true })
+	})
+
+	it('does not deadlock when two deletes race on mutually-referencing tasks', async () => {
+		const a = await store.create({ runId, subject: 'A' })
+		const b = await store.create({ runId, subject: 'B' })
+
+		// Establish bidirectional edge: A blocks B AND B blocks A.
+		// (Nonsensical semantically, but the store allows it and the lock logic
+		// must not deadlock.)
+		await store.block(a.id, b.id)
+		await store.block(b.id, a.id)
+
+		// Race the two deletes. The pre-fix implementation (lock this → iterate
+		// related → lock each) could acquire A→B from one call and B→A from the
+		// other, deadlocking. withLocks() sorts IDs canonically so both calls
+		// acquire [A, B] in the same order.
+		const withTimeout = <T>(p: Promise<T>, ms: number): Promise<T> =>
+			Promise.race([
+				p,
+				new Promise<never>((_resolve, reject) =>
+					setTimeout(() => reject(new Error('timeout — likely deadlocked')), ms),
+				),
+			])
+
+		const [resA, resB] = await withTimeout(
+			Promise.all([store.delete(a.id), store.delete(b.id)]),
+			2000,
+		)
+		expect(resA).toBe(true)
+		expect(resB).toBe(true)
+		expect(await store.get(a.id)).toBeUndefined()
+		expect(await store.get(b.id)).toBeUndefined()
+	})
+
+	it('serializes concurrent same-ID updates (withLock race regression)', async () => {
+		const task = await store.create({ runId, subject: 'shared' })
+
+		// update()'s metadata merge does `{ ...task.metadata, ...updates.metadata }`
+		// inside withLock. If withLock serializes correctly, every update's key
+		// survives into the final metadata (each sees the latest merged state).
+		// If withLock had the race bug, two concurrent updates would both read
+		// the SAME snapshot, each add their one key, and one update's key would
+		// be overwritten when the second committed — yielding < N keys in the
+		// final metadata.
+		const n = 20
+		await Promise.all(
+			Array.from({ length: n }, (_v, i) =>
+				store.update(task.id, { metadata: { [`k${i}`]: true } }),
+			),
+		)
+
+		const final = await store.get(task.id)
+		const keys = Object.keys(final?.metadata ?? {})
+		expect(keys).toHaveLength(n)
+		for (let i = 0; i < n; i++) {
+			expect(final?.metadata?.[`k${i}`]).toBe(true)
+		}
+	})
+
+	it('establishes bidirectional edge atomically under create()', async () => {
+		const blocker = await store.create({ runId, subject: 'blocker' })
+
+		// Race: create a child with blockedBy=[blocker] while concurrently
+		// deleting the blocker. Either outcome is acceptable (child created
+		// and blocker still present in its blocks list, OR blocker gone and
+		// child created with dangling reference), but we must NEVER see
+		// blocker still present WITHOUT having child in its blocks list.
+		const tasks = await Promise.all([
+			store.create({ runId, subject: 'child', blockedBy: [blocker.id] }),
+			// No delete here — keep the create edge test focused. The point is
+			// that after create() resolves, the blocker's blocks list contains
+			// the new task ID atomically.
+		])
+		const child = tasks[0]
+
+		const blockerAfter = await store.get(blocker.id)
+		expect(blockerAfter).toBeDefined()
+		expect(blockerAfter?.blocks).toContain(child.id)
+		expect(child.blockedBy).toContain(blocker.id)
+	})
+
+	it('block() skips gracefully when one task disappeared before lock acquired', async () => {
+		const a = await store.create({ runId, subject: 'A' })
+		const b = await store.create({ runId, subject: 'B' })
+
+		// Delete B, then try to block a → b. The findTask pre-check passes for a
+		// but fails for b, so block() returns early (silent no-op per existing
+		// contract).
+		await store.delete(b.id)
+
+		// block() should not throw and A's blocks list should remain empty.
+		await store.block(a.id, b.id)
+
+		const aAfter = await store.get(a.id)
+		expect(aAfter?.blocks).not.toContain(b.id)
+	})
+})

package/src/store/task/disk.ts

@@ -61,8 +61,13 @@ export class DiskTaskStore implements TaskStore {
 	}
 
 	private async withLock<T>(taskId: TaskId, fn: () => Promise<T>): Promise<T> {
-		const existing = this.locks.get(taskId)
-		if (existing) {
+		// Loop instead of single await: after awaiting a lock, the map may
+		// already hold a NEW lock acquired by another coroutine that woke
+		// up before us. Re-check on each iteration until we observe an empty
+		// slot, at which point the synchronous set() below claims it.
+		while (true) {
+			const existing = this.locks.get(taskId)
+			if (!existing) break
 			await existing.catch(() => undefined)
 		}
 
@@ -82,6 +87,22 @@ export class DiskTaskStore implements TaskStore {
 		}
 	}
 
+	/**
+	 * Acquires locks on multiple task IDs in a canonical (lexicographic) order
+	 * to prevent deadlocks when operations touch several related tasks.
+	 * Duplicates are removed; each ID is locked exactly once.
+	 */
+	private async withLocks<T>(taskIds: readonly TaskId[], fn: () => Promise<T>): Promise<T> {
+		const unique = [...new Set(taskIds)].sort() as TaskId[]
+		const acquire = async (i: number): Promise<T> => {
+			if (i >= unique.length) return fn()
+			const nextId = unique[i]
+			if (nextId === undefined) return fn()
+			return this.withLock(nextId, () => acquire(i + 1))
+		}
+		return acquire(0)
+	}
+
 	on(listener: TaskEventListener): () => void {
 		this.listeners.push(listener)
 		return () => {
@@ -93,7 +114,12 @@ export class DiskTaskStore implements TaskStore {
 		for (const listener of this.listeners) {
 			try {
 				listener(event)
-			} catch {}
+			} catch (err) {
+				this.log.warn('Task event listener threw', {
+					error: err instanceof Error ? err.message : String(err),
+					eventType: event.type,
+				})
+			}
 		}
 	}
 
@@ -118,18 +144,27 @@ export class DiskTaskStore implements TaskStore {
 
 		const dir = this.taskDir(runId)
 		await mkdir(dir, { recursive: true })
-		await atomicWriteJson(this.taskPath(runId, taskId), task)
 
-		if (params.blockedBy) {
-			for (const blockerId of params.blockedBy) {
-				await this.withLock(blockerId, async () => {
+		const blockers = params.blockedBy ?? []
+		if (blockers.length === 0) {
+			await atomicWriteJson(this.taskPath(runId, taskId), task)
+		} else {
+			// Hold locks on all blockers while establishing the bidirectional edge:
+			// update each blocker's `blocks` list AND write the new task together,
+			// so concurrent delete(blockerId) sees a consistent pair.
+			await this.withLocks(blockers, async () => {
+				for (const blockerId of blockers) {
 					const blocker = await this.readTask(runId, blockerId)
 					if (blocker && !blocker.blocks.includes(taskId)) {
 						blocker.blocks.push(taskId)
 						await atomicWriteJson(this.taskPath(runId, blockerId), blocker)
 					}
-				})
-			}
+					// If blocker is missing, we still write the new task with its
+					// blockedBy reference; the dangling reference is visible to
+					// subsequent readers rather than silently pruned.
+				}
+				await atomicWriteJson(this.taskPath(runId, taskId), task)
+			})
 		}
 
 		this.log.info('Task created', { taskId, subject: params.subject, runId })
@@ -185,30 +220,59 @@ export class DiskTaskStore implements TaskStore {
 		const found = await this.findTask(id)
 		if (!found) return false
 
-		return this.withLock(id, async () => {
+		// Read the task once (unlocked) to discover its related IDs, then acquire
+		// locks on the entire set (self + blockers + blocked) in canonical order.
+		// Locking the full set up-front in sorted order prevents deadlock when two
+		// deletes race on tasks that mutually reference each other.
+		//
+		// Known trade-off: the lock set is computed from the unlocked preview. If
+		// create()/block() adds a NEW relation between preview and lock acquisition,
+		// we will mutate that neighbor without holding its lock. The alternative
+		// (retry loop with expanding lock set) adds substantial complexity for a
+		// rare interleaving in a single-tenant single-writer store; revisit if the
+		// store grows concurrent writers.
+		const preview = await this.readTask(found.runId, id)
+		if (!preview) return false
+
+		const relatedIds: TaskId[] = [id, ...preview.blockedBy, ...preview.blocks]
+
+		return this.withLocks(relatedIds, async () => {
+			// Re-read under lock: the task's block graph may have changed between
+			// the unlocked preview and lock acquisition.
 			const task = await this.readTask(found.runId, id)
 			if (!task) return false
 
 			for (const blockerId of task.blockedBy) {
-				await this.withLock(blockerId, async () => {
-					const blocker = await this.readTask(task.runId, blockerId)
-					if (blocker) {
-						blocker.blocks = blocker.blocks.filter((bid) => bid !== id)
-						await atomicWriteJson(this.taskPath(task.runId, blockerId), blocker)
-					}
-				})
+				const blocker = await this.readTask(task.runId, blockerId)
+				if (blocker) {
+					blocker.blocks = blocker.blocks.filter((bid) => bid !== id)
+					await atomicWriteJson(this.taskPath(task.runId, blockerId), blocker)
+				}
 			}
 			for (const blockedId of task.blocks) {
-				await this.withLock(blockedId, async () => {
-					const blocked = await this.readTask(task.runId, blockedId)
-					if (blocked) {
-						blocked.blockedBy = blocked.blockedBy.filter((bid) => bid !== id)
-						await atomicWriteJson(this.taskPath(task.runId, blockedId), blocked)
-					}
-				})
+				const blocked = await this.readTask(task.runId, blockedId)
+				if (blocked) {
+					blocked.blockedBy = blocked.blockedBy.filter((bid) => bid !== id)
+					await atomicWriteJson(this.taskPath(task.runId, blockedId), blocked)
+				}
 			}
 
-			await unlink(this.taskPath(task.runId, id)).catch(() => undefined)
+			try {
+				await unlink(this.taskPath(task.runId, id))
+			} catch (err) {
+				const code = (err as NodeJS.ErrnoException).code
+				if (code !== 'ENOENT') {
+					this.log.error(
+						'Failed to delete task file; relations may be in a partially-updated state',
+						{
+							taskId: id,
+							error: err instanceof Error ? err.message : String(err),
+						},
+					)
+					throw err
+				}
+				// ENOENT: already gone, treat as success.
+			}
 			this.log.info('Task deleted', { taskId: id })
 			this.emit({ type: 'task.deleted', taskId: id, task, timestamp: Date.now() })
 			return true
@@ -222,7 +286,13 @@ export class DiskTaskStore implements TaskStore {
 		let files: string[]
 		try {
 			files = await readdir(dir)
-		} catch {
+		} catch (err) {
+			const code = (err as NodeJS.ErrnoException).code
+			if (code === 'ENOENT') return []
+			this.log.warn('Failed to list task directory', {
+				dir,
+				error: err instanceof Error ? err.message : String(err),
+			})
 			return []
 		}
 
@@ -233,8 +303,11 @@ export class DiskTaskStore implements TaskStore {
 				const raw = await readFile(join(dir, file), 'utf-8')
 				const task = JSON.parse(raw) as Task
 				tasks.push(task)
-			} catch {
-				this.log.warn('Failed to read task file', { file })
+			} catch (err) {
+				this.log.warn('Failed to read task file', {
+					file,
+					error: err instanceof Error ? err.message : String(err),
+				})
 			}
 		}
 
@@ -274,19 +347,40 @@ export class DiskTaskStore implements TaskStore {
 		const blockedFound = await this.findTask(blockedId)
 		if (!blockerFound || !blockedFound) return
 
-		await this.withLock(blockerId, async () => {
+		// Acquire BOTH locks before mutating either side of the edge. Sequential
+		// single-locks allow a concurrent operation to interleave and observe
+		// a half-established relationship.
+		await this.withLocks([blockerId, blockedId], async () => {
 			const blocker = await this.readTask(blockerFound.runId, blockerId)
-			if (blocker && !blocker.blocks.includes(blockedId)) {
+			const blocked = await this.readTask(blockedFound.runId, blockedId)
+
+			// Re-validate under lock: either side may have been deleted between
+			// the pre-check (findTask) and lock acquisition. Establishing only
+			// one side of the edge would leave a dangling reference; skip the
+			// whole operation instead.
+			if (!blocker || !blocked) {
+				this.log.warn('block(): task disappeared before lock acquired; skipping', {
+					blockerId,
+					blockedId,
+					blockerExists: !!blocker,
+					blockedExists: !!blocked,
+				})
+				return
+			}
+
+			let mutated = false
+			if (!blocker.blocks.includes(blockedId)) {
 				blocker.blocks.push(blockedId)
 				await atomicWriteJson(this.taskPath(blocker.runId, blockerId), blocker)
+				mutated = true
 			}
-		})
-
-		await this.withLock(blockedId, async () => {
-			const blocked = await this.readTask(blockedFound.runId, blockedId)
-			if (blocked && !blocked.blockedBy.includes(blockerId)) {
+			if (!blocked.blockedBy.includes(blockerId)) {
 				blocked.blockedBy.push(blockerId)
 				await atomicWriteJson(this.taskPath(blocked.runId, blockedId), blocked)
+				mutated = true
+			}
+			if (!mutated) {
+				this.log.debug('block(): edge already exists', { blockerId, blockedId })
 			}
 		})
 	}
@@ -307,10 +401,29 @@ export class DiskTaskStore implements TaskStore {
 	}
 
 	private async readTask(runId: RunId, taskId: TaskId): Promise<Task | null> {
+		const path = this.taskPath(runId, taskId)
+		let raw: string
+		try {
+			raw = await readFile(path, 'utf-8')
+		} catch (err) {
+			const code = (err as NodeJS.ErrnoException).code
+			if (code === 'ENOENT') return null
+			this.log.warn('Failed to read task', {
+				taskId,
+				path,
+				error: err instanceof Error ? err.message : String(err),
+			})
+			return null
+		}
+
 		try {
-			const raw = await readFile(this.taskPath(runId, taskId), 'utf-8')
 			return JSON.parse(raw) as Task
-		} catch {
+		} catch (err) {
+			this.log.error('Corrupt task JSON on disk', {
+				taskId,
+				path,
+				error: err instanceof Error ? err.message : String(err),
+			})
 			return null
 		}
 	}

package/src/types/connector/core.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod'
-import type { ConnectorInstanceId } from '../ids/index.js'
+import type { ConnectorId, ConnectorInstanceId } from '../ids/index.js'
 
 export type ConnectionType = 'http' | 'webhook' | 'custom'
 
@@ -39,7 +39,7 @@ export interface ConnectorTrigger {
 }
 
 export interface ConnectorEvent {
-	connectorId: string
+	connectorId: ConnectorId
 	instanceId: ConnectorInstanceId
 	trigger: string
 	payload: unknown

package/src/types/connector/definition.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod'
-import type { ConnectorInstanceId } from '../ids/index.js'
+import type { ConnectorId, ConnectorInstanceId } from '../ids/index.js'
 import type {
 	AuthConfig,
 	AuthType,
@@ -11,7 +11,7 @@ import type {
 } from './core.js'
 
 export interface ConnectorDefinition<TConfig = unknown> {
-	id: string
+	id: ConnectorId
 	name: string
 	description: string
 	version?: string
@@ -24,7 +24,7 @@ export interface ConnectorDefinition<TConfig = unknown> {
 }
 
 export interface ConnectorConfig {
-	connectorId: string
+	connectorId: ConnectorId
 	name: string
 	auth?: AuthConfig
 	options?: Record<string, unknown>
@@ -32,7 +32,7 @@ export interface ConnectorConfig {
 
 export interface ConnectorInstance {
 	id: ConnectorInstanceId
-	connectorId: string
+	connectorId: ConnectorId
 	config: ConnectorConfig
 	status: ConnectorStatus
 	createdAt: number
@@ -63,9 +63,9 @@ export interface ConnectorLifecycle<TConfig = unknown> {
 }
 
 export type ConnectorLifecycleEvent =
-	| { type: 'connector_registered'; connectorId: string }
-	| { type: 'connector_unregistered'; connectorId: string }
-	| { type: 'instance_created'; instanceId: ConnectorInstanceId; connectorId: string }
+	| { type: 'connector_registered'; connectorId: ConnectorId }
+	| { type: 'connector_unregistered'; connectorId: ConnectorId }
+	| { type: 'instance_created'; instanceId: ConnectorInstanceId; connectorId: ConnectorId }
 	| { type: 'instance_connecting'; instanceId: ConnectorInstanceId }
 	| { type: 'instance_connected'; instanceId: ConnectorInstanceId }
 	| { type: 'instance_disconnected'; instanceId: ConnectorInstanceId }

package/src/types/connector/mcp.ts

@@ -1,4 +1,4 @@
-import type { ConnectorInstanceId, MCPClientId, MCPServerId } from '../ids/index.js'
+import type { ConnectorId, ConnectorInstanceId, MCPClientId, MCPServerId } from '../ids/index.js'
 import type {
 	ConnectorDefinition,
 	ConnectorExecuteParams,
@@ -180,7 +180,7 @@ export interface MCPConnectorBridgeConfig {
 
 export interface MCPConnectorBridgeToolMapping {
 	mcpToolName: string
-	connectorId: string
+	connectorId: ConnectorId
 	instanceId: ConnectorInstanceId
 	methodName: string
 }
@@ -205,8 +205,8 @@ export type MCPEventListener = (event: MCPLifecycleEvent) => void
 type ConnectorManager = {
 	getInstance(instanceId: ConnectorInstanceId): ConnectorInstance | undefined
 	getRegistry(): {
-		get(connectorId: string): ConnectorDefinition | undefined
-		getOrThrow(connectorId: string): ConnectorDefinition
+		get(connectorId: ConnectorId): ConnectorDefinition | undefined
+		getOrThrow(connectorId: ConnectorId): ConnectorDefinition
 	}
 	listConnectedInstances(): ConnectorInstance[]
 	execute(params: ConnectorExecuteParams): Promise<ConnectorExecuteResult>

package/src/types/connector/scope.ts

@@ -1,3 +1,4 @@
+import type { ConnectorId } from '../ids/index.js'
 import type { AuthConfig } from './core.js'
 import type { ConnectorConfig } from './definition.js'
 
@@ -18,7 +19,7 @@ export interface ScopeRef {
 
 export interface ScopedConnectorConfig {
 	scope: ScopeRef
-	connectorId: string
+	connectorId: ConnectorId
 
 	config?: Partial<ConnectorConfig>
 
@@ -30,7 +31,7 @@ export interface ScopedConnectorConfig {
 }
 
 export interface ResolvedConnectorConfig {
-	connectorId: string
+	connectorId: ConnectorId
 	config: ConnectorConfig
 	auth?: AuthConfig
 	enabled: boolean

package/src/types/connector/tenant.ts

@@ -1,4 +1,4 @@
-import type { CredentialId, EnvironmentId, TenantId } from '../ids/index.js'
+import type { ConnectorId, CredentialId, EnvironmentId, TenantId } from '../ids/index.js'
 import type { AuthConfig, AuthType } from './core.js'
 
 export type EnvironmentTier = 'production' | 'staging' | 'development' | 'testing'
@@ -25,7 +25,7 @@ export interface TenantRateLimitConfig {
 
 export interface CredentialRef {
 	id: CredentialId
-	connectorId: string
+	connectorId: ConnectorId
 	tenantId: TenantId
 	label: string
 	authType: AuthType
@@ -36,11 +36,11 @@ export interface CredentialRef {
 export interface CredentialVault {
 	store(
 		tenantId: TenantId,
-		connectorId: string,
+		connectorId: ConnectorId,
 		label: string,
 		auth: AuthConfig,
 	): Promise<CredentialRef>
 	retrieve(credentialId: CredentialId): Promise<AuthConfig | undefined>
 	revoke(credentialId: CredentialId): Promise<boolean>
-	list(tenantId: TenantId, connectorId?: string): Promise<CredentialRef[]>
+	list(tenantId: TenantId, connectorId?: ConnectorId): Promise<CredentialRef[]>
 }

package/src/types/rag/knowledge-base.ts

@@ -1,4 +1,4 @@
-import type { DocumentId, KnowledgeBaseId } from '../ids/index.js'
+import type { DocumentId, KnowledgeBaseId, TenantId } from '../ids/index.js'
 import type { ChunkingConfig } from './chunking.js'
 import type { EmbeddingConfig } from './embedding.js'
 import type { IngestionResult } from './ingestion.js'
@@ -9,7 +9,7 @@ export interface KnowledgeBaseConfig {
 	id?: KnowledgeBaseId
 	name: string
 	description?: string
-	tenantId: string
+	tenantId: TenantId
 	namespace?: string
 	chunking?: Partial<ChunkingConfig>
 	retrieval?: Partial<RetrievalConfig>

package/src/types/rag/scope.ts

@@ -1,5 +1,7 @@
+import type { TenantId } from '../ids/index.js'
+
 export interface TenantScope {
-	tenantId: string
+	tenantId: TenantId
 	namespace?: string
 }
 

package/src/types/rag/storage.ts

@@ -1,10 +1,10 @@
-import type { ChunkId, DocumentId, KnowledgeBaseId } from '../ids/index.js'
+import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../ids/index.js'
 import type { DocumentMetadata } from './scope.js'
 
 export interface Document {
 	id: DocumentId
 	knowledgeBaseId: KnowledgeBaseId
-	tenantId: string
+	tenantId: TenantId
 	content: string
 	metadata: DocumentMetadata
 	createdAt: number
@@ -15,7 +15,7 @@ export interface Chunk {
 	id: ChunkId
 	documentId: DocumentId
 	knowledgeBaseId: KnowledgeBaseId
-	tenantId: string
+	tenantId: TenantId
 	content: string
 	index: number
 	tokenCount: number

package/src/types/rag/vector.ts

@@ -1,4 +1,4 @@
-import type { ChunkId, DocumentId, KnowledgeBaseId } from '../ids/index.js'
+import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../ids/index.js'
 import type { Chunk } from './storage.js'
 
 export interface VectorSearchResult {
@@ -9,7 +9,7 @@ export interface VectorSearchResult {
 export interface VectorStoreQuery {
 	embedding: number[]
 	topK: number
-	tenantId: string
+	tenantId: TenantId
 	knowledgeBaseId?: KnowledgeBaseId
 	filter?: Record<string, unknown>
 	minScore?: number
@@ -20,5 +20,5 @@ export interface VectorStore {
 	search(query: VectorStoreQuery): Promise<VectorSearchResult[]>
 	delete(chunkIds: ChunkId[]): Promise<void>
 	deleteByDocument(documentId: DocumentId): Promise<void>
-	deleteByKnowledgeBase(knowledgeBaseId: KnowledgeBaseId, tenantId: string): Promise<void>
+	deleteByKnowledgeBase(knowledgeBaseId: KnowledgeBaseId, tenantId: TenantId): Promise<void>
 }

package/src/vault/InMemoryCredentialVault.ts

@@ -1,5 +1,5 @@
 import type { AuthConfig, CredentialRef, CredentialVault } from '../types/connector/index.js'
-import type { CredentialId, TenantId } from '../types/ids/index.js'
+import type { ConnectorId, CredentialId, TenantId } from '../types/ids/index.js'
 import { generateCredentialId } from '../utils/id.js'
 import { type Logger, getRootLogger } from '../utils/logger.js'
 
@@ -14,7 +14,7 @@ export class InMemoryCredentialVault implements CredentialVault {
 
 	async store(
 		tenantId: TenantId,
-		connectorId: string,
+		connectorId: ConnectorId,
 		label: string,
 		auth: AuthConfig,
 	): Promise<CredentialRef> {
@@ -48,7 +48,7 @@ export class InMemoryCredentialVault implements CredentialVault {
 		return existed
 	}
 
-	async list(tenantId: TenantId, connectorId?: string): Promise<CredentialRef[]> {
+	async list(tenantId: TenantId, connectorId?: ConnectorId): Promise<CredentialRef[]> {
 		const results: CredentialRef[] = []
 		for (const ref of this.refs.values()) {
 			if (ref.tenantId !== tenantId) continue

package/dist/manager/agent/index.d.ts

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

package/dist/manager/agent/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/manager/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/manager/agent/index.js

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

package/dist/manager/agent/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/manager/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/registry/agent/index.d.ts

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

package/dist/registry/agent/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/registry/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/registry/agent/index.js

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

package/dist/registry/agent/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/registry/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/router/index.d.ts

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

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

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

package/dist/router/index.js

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