@canonmsg/core 0.2.2 → 0.4.0

package/dist/agent-resolver.d.ts

@@ -17,6 +17,10 @@ export interface ResolvedAgent {
 }
 /** Get the currently locked profile name (for cleanup on shutdown). */
 export declare function getActiveProfile(): string | null;
+export declare function resolveCanonProfile(name: string, opts?: {
+    logPrefix?: string;
+    lock?: boolean;
+}): ResolvedAgent;
 /**
  * Resolve Canon agent credentials.
  *

package/dist/agent-resolver.js

@@ -16,6 +16,26 @@ let activeResolvedProfile = null;
 export function getActiveProfile() {
     return activeResolvedProfile;
 }
+export function resolveCanonProfile(name, opts) {
+    const prefix = opts?.logPrefix ?? '[canon]';
+    const profileName = name.trim();
+    if (!profileName) {
+        throw new Error(`${prefix} Profile name is required`);
+    }
+    const profiles = loadProfiles();
+    const profile = profiles[profileName];
+    if (!profile) {
+        throw new Error(`${prefix} Profile "${profileName}" not found in ~/.canon/agents.json`);
+    }
+    if (opts?.lock) {
+        acquireLock(profileName);
+    }
+    return {
+        apiKey: profile.apiKey,
+        agentId: profile.agentId,
+        profile: profileName,
+    };
+}
 /**
  * Resolve Canon agent credentials.
  *
@@ -36,32 +56,35 @@ export function resolveCanonAgent(opts) {
     const names = Object.keys(profiles);
     // 2. Named profile via env var
     if (process.env.CANON_AGENT) {
-        const name = process.env.CANON_AGENT;
-        const p = profiles[name];
-        if (!p) {
-            throw new Error(`${prefix} Profile "${name}" not found in ~/.canon/agents.json`);
-        }
-        acquireLock(name);
-        activeResolvedProfile = name;
-        return { apiKey: p.apiKey, agentId: p.agentId, profile: name };
+        const resolved = resolveCanonProfile(process.env.CANON_AGENT, {
+            logPrefix: prefix,
+            lock: true,
+        });
+        activeResolvedProfile = resolved.profile;
+        return resolved;
     }
     // 3. Auto-select from profiles
     if (names.length === 0) {
         throw new Error(`${prefix} No agents registered. Run canon-register first.`);
     }
     if (names.length === 1) {
-        const name = names[0];
-        acquireLock(name);
-        activeResolvedProfile = name;
-        return { apiKey: profiles[name].apiKey, agentId: profiles[name].agentId, profile: name };
+        const resolved = resolveCanonProfile(names[0], {
+            logPrefix: prefix,
+            lock: true,
+        });
+        activeResolvedProfile = resolved.profile;
+        return resolved;
     }
     // Multiple agents — pick first unlocked
     for (const name of names) {
         if (!isProfileLocked(name).locked) {
-            acquireLock(name);
-            activeResolvedProfile = name;
+            const resolved = resolveCanonProfile(name, {
+                logPrefix: prefix,
+                lock: true,
+            });
+            activeResolvedProfile = resolved.profile;
             console.error(`${prefix} Auto-selected agent "${name}" (${profiles[name].agentName})`);
-            return { apiKey: profiles[name].apiKey, agentId: profiles[name].agentId, profile: name };
+            return resolved;
         }
     }
     throw new Error(`${prefix} All agents are in use by other sessions.`);

package/dist/browser.d.ts

@@ -0,0 +1,6 @@
+export { AGENT_CAPABILITIES, } from './types.js';
+export type { AgentCapabilities, AgentClientType, AgentRuntime, MediaAttachment, MediaAttachmentKind, ModelOption, SessionConfig, WorkspaceOption, } from './types.js';
+export type { AgentBehaviorSettings, ParticipationHistoryMessage, ParticipationHistorySnapshot, ParticipationStyle, ResolvedAgentBehaviorPolicy, } from './policy.js';
+export { buildParticipationHistorySnapshot, buildParticipationHistorySnapshots, buildBehaviorPolicyLines, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, evaluateParticipationPolicy, getDefaultParticipationPolicy, resolveAgentBehaviorPolicy, } from './policy.js';
+export { DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, isTurnOpen, normalizeTurnMetadata, normalizeTurnState, resolveTurnMessageSemantics, shouldPromoteConversationMessage, shouldTriggerAgentTurn, } from './turn-protocol.js';
+export type { DeliveryIntent, InboundDisposition, RuntimeCapabilities, TriggerDecision, TurnLifecycleState, TurnMessageSemantics, TurnMetadata, TurnState, } from './turn-protocol.js';

package/dist/browser.js

@@ -0,0 +1,3 @@
+export { AGENT_CAPABILITIES, } from './types.js';
+export { buildParticipationHistorySnapshot, buildParticipationHistorySnapshots, buildBehaviorPolicyLines, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, evaluateParticipationPolicy, getDefaultParticipationPolicy, resolveAgentBehaviorPolicy, } from './policy.js';
+export { DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, isTurnOpen, normalizeTurnMetadata, normalizeTurnState, resolveTurnMessageSemantics, shouldPromoteConversationMessage, shouldTriggerAgentTurn, } from './turn-protocol.js';

package/dist/client.d.ts

@@ -1,4 +1,5 @@
-import { type CanonMessage, type CanonConversation, type AgentContext, type SendMessageOptions, type CreateConversationOptions, type RegistrationStatus, type SetStreamingOptions } from './types.js';
+import { type CanonMessage, type CanonConversation, type CanonMessagesPage, type AgentContext, type MediaAttachment, type SendMessageOptions, type CreateConversationOptions, type RegistrationStatus, type SetStreamingOptions } from './types.js';
+import type { InboundDisposition } from './turn-protocol.js';
 /**
  * Thin REST client for Canon's agent API.
  * Uses native fetch — no runtime dependencies.
@@ -16,17 +17,20 @@ export declare class CanonClient {
     getAgentMe(): Promise<AgentContext>;
     getConversations(): Promise<CanonConversation[]>;
     getMessages(conversationId: string, limit?: number, before?: string): Promise<CanonMessage[]>;
+    getMessagesPage(conversationId: string, limit?: number, before?: string): Promise<CanonMessagesPage>;
     sendMessage(conversationId: string, text: string, options?: SendMessageOptions): Promise<{
         messageId: string;
     }>;
     createConversation(options: CreateConversationOptions): Promise<{
         conversationId: string;
     }>;
-    uploadMedia(conversationId: string, data: string, mimeType: string): Promise<{
+    uploadMedia(conversationId: string, data: string, mimeType: string, fileName?: string): Promise<{
         url: string;
+        attachment: MediaAttachment;
     }>;
     updateTopic(conversationId: string, topic: string): Promise<void>;
     deleteMessage(conversationId: string, messageId: string): Promise<void>;
+    updateMessageDisposition(conversationId: string, messageId: string, inboundDisposition: InboundDisposition): Promise<void>;
     markAsRead(conversationId: string): Promise<void>;
     leaveConversation(conversationId: string): Promise<void>;
     react(conversationId: string, messageId: string, emoji: string): Promise<void>;

package/dist/client.js

@@ -53,6 +53,16 @@ export class CanonClient {
         const data = await res.json();
         return data.messages;
     }
+    async getMessagesPage(conversationId, limit = 50, before) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (before)
+            params.set('before', before);
+        params.set('includeBehavior', '1');
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages?${params}`, { headers: this.authHeaders() });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+        return res.json();
+    }
     async sendMessage(conversationId, text, options) {
         const res = await fetch(`${this.baseUrl}/messages/send`, {
             method: 'POST',
@@ -73,11 +83,11 @@ export class CanonClient {
             throw new CanonApiError(res.status, await res.text());
         return res.json();
     }
-    async uploadMedia(conversationId, data, mimeType) {
+    async uploadMedia(conversationId, data, mimeType, fileName) {
         const res = await fetch(`${this.baseUrl}/media/upload`, {
             method: 'POST',
             headers: this.authHeaders(),
-            body: JSON.stringify({ conversationId, mimeType, data }),
+            body: JSON.stringify({ conversationId, mimeType, data, ...(fileName ? { fileName } : {}) }),
         });
         if (!res.ok)
             throw new CanonApiError(res.status, await res.text());
@@ -100,6 +110,15 @@ export class CanonClient {
         if (!res.ok)
             throw new CanonApiError(res.status, await res.text());
     }
+    async updateMessageDisposition(conversationId, messageId, inboundDisposition) {
+        const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/messages/${messageId}/disposition`, {
+            method: 'PATCH',
+            headers: this.authHeaders(),
+            body: JSON.stringify({ inboundDisposition }),
+        });
+        if (!res.ok)
+            throw new CanonApiError(res.status, await res.text());
+    }
     async markAsRead(conversationId) {
         const res = await fetch(`${this.baseUrl}/conversations/${conversationId}/read`, {
             method: 'POST',

package/dist/execution-environment.d.ts

@@ -0,0 +1,59 @@
+import type { WorkspaceOption } from './types.js';
+export type ExecutionEnvironmentMode = 'worktree' | 'locked';
+export interface PreparedExecutionEnvironment {
+    cwd: string;
+    baseCwd: string;
+    mode: ExecutionEnvironmentMode;
+    repoRoot?: string;
+    branch?: string;
+    worktreePath?: string;
+    lockPath?: string;
+    reason?: string;
+}
+export declare class ExecutionEnvironmentError extends Error {
+    readonly userMessage: string;
+    constructor(message: string, userMessage?: string);
+}
+interface WorkspaceResolverOption {
+    id: string;
+    cwd: string;
+}
+export interface ConfiguredWorkspaceOption extends WorkspaceResolverOption {
+    label: string;
+}
+export interface SessionWorkspaceConfig {
+    workspaceId?: string;
+    legacyCwd?: string;
+    model?: string;
+}
+export declare function normalizeOptionalString(value: unknown): string | undefined;
+export declare function isEnabledFlag(value: unknown): boolean;
+export declare function buildConversationEnvironmentKey(conversationId: string, workspaceCwd: string): string;
+export declare function buildWorkspaceOptionId(workspaceCwd: string): string;
+export declare function buildConfiguredWorkspaceOptions(primaryCwd: string, configured: string[]): ConfiguredWorkspaceOption[];
+export declare function buildPublicWorkspaceOptions(workspaceOptions: Array<Pick<ConfiguredWorkspaceOption, 'id' | 'label'>>): WorkspaceOption[];
+export declare function readSessionWorkspaceConfig(raw: unknown): SessionWorkspaceConfig | null;
+export declare function resolveConfiguredWorkspaceCwd(input: {
+    workspaceOptions: WorkspaceResolverOption[];
+    config: {
+        workspaceId?: string;
+        legacyCwd?: string;
+    } | null;
+    defaultCwd: string;
+}): string;
+export declare function buildConversationWorktreeSpec(input: {
+    agentId: string;
+    conversationId: string;
+    workspaceCwd: string;
+}): {
+    branch: string;
+    worktreePath: string;
+};
+export declare function prepareConversationEnvironment(input: {
+    agentId: string;
+    conversationId: string;
+    workspaceCwd: string;
+    allowWorktrees?: boolean;
+}): PreparedExecutionEnvironment;
+export declare function releaseConversationEnvironment(environment: Pick<PreparedExecutionEnvironment, 'lockPath'>): void;
+export {};

package/dist/execution-environment.js

@@ -0,0 +1,284 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { CANON_DIR, isProcessAlive } from './agent-profiles.js';
+export class ExecutionEnvironmentError extends Error {
+    userMessage;
+    constructor(message, userMessage = message) {
+        super(message);
+        this.name = 'ExecutionEnvironmentError';
+        this.userMessage = userMessage;
+    }
+}
+const WORKTREE_ROOT = join(CANON_DIR, 'conversation-worktrees');
+const WORKSPACE_LOCKS_ROOT = join(CANON_DIR, 'workspace-locks');
+export function normalizeOptionalString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function isEnabledFlag(value) {
+    if (value === true)
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function shortHash(value) {
+    return createHash('sha256').update(value).digest('hex').slice(0, 12);
+}
+function sanitizeSegment(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized.slice(0, 24) || 'workspace';
+}
+function runGit(cwd, args) {
+    const result = spawnSync('git', ['-C', cwd, ...args], {
+        encoding: 'utf-8',
+    });
+    return {
+        ok: result.status === 0,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+    };
+}
+function detectRepoRoot(cwd) {
+    const result = runGit(cwd, ['rev-parse', '--show-toplevel']);
+    if (!result.ok)
+        return null;
+    const repoRoot = result.stdout.trim();
+    return repoRoot ? resolve(repoRoot) : null;
+}
+function isRepoClean(repoRoot) {
+    const result = runGit(repoRoot, ['status', '--porcelain']);
+    return result.ok && result.stdout.trim() === '';
+}
+function branchExists(repoRoot, branch) {
+    return runGit(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]).ok;
+}
+function loadWorkspaceLock(lockPath) {
+    try {
+        return JSON.parse(readFileSync(lockPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupStaleWorkspaceLock(lockPath) {
+    const record = loadWorkspaceLock(lockPath);
+    if (!record) {
+        try {
+            unlinkSync(lockPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (isProcessAlive(record.pid))
+        return false;
+    try {
+        unlinkSync(lockPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function acquireWorkspaceLock(input) {
+    mkdirSync(WORKSPACE_LOCKS_ROOT, { recursive: true });
+    const workspaceCwd = resolve(input.workspaceCwd);
+    const lockPath = join(WORKSPACE_LOCKS_ROOT, `${shortHash(workspaceCwd)}.json`);
+    const record = {
+        pid: process.pid,
+        agentId: input.agentId,
+        conversationId: input.conversationId,
+        workspaceCwd,
+        createdAt: new Date().toISOString(),
+    };
+    while (true) {
+        try {
+            writeFileSync(lockPath, JSON.stringify(record, null, 2), { flag: 'wx' });
+            return lockPath;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            const existing = loadWorkspaceLock(lockPath);
+            if (!existing) {
+                if (cleanupStaleWorkspaceLock(lockPath))
+                    continue;
+                throw new Error(`Workspace lock file is unreadable: ${workspaceCwd}`);
+            }
+            if (!isProcessAlive(existing.pid)) {
+                if (cleanupStaleWorkspaceLock(lockPath))
+                    continue;
+            }
+            if (existing.pid === process.pid
+                && existing.agentId === input.agentId
+                && existing.conversationId === input.conversationId) {
+                return lockPath;
+            }
+            throw new ExecutionEnvironmentError(`Workspace is already in use by Canon session ${existing.conversationId.slice(0, 8)} (PID ${existing.pid}).`, 'That workspace is already in use by another Canon coding session on this machine.');
+        }
+    }
+}
+export function buildConversationEnvironmentKey(conversationId, workspaceCwd) {
+    return `${conversationId}:${resolve(workspaceCwd)}`;
+}
+export function buildWorkspaceOptionId(workspaceCwd) {
+    return `workspace-${shortHash(resolve(workspaceCwd))}`;
+}
+export function buildConfiguredWorkspaceOptions(primaryCwd, configured) {
+    const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
+    const seenLabels = new Map();
+    return uniqueDirs.map((cwd) => {
+        const baseLabel = basename(cwd) || cwd;
+        const seenCount = (seenLabels.get(baseLabel) ?? 0) + 1;
+        seenLabels.set(baseLabel, seenCount);
+        return {
+            id: buildWorkspaceOptionId(cwd),
+            label: seenCount === 1 ? baseLabel : `${baseLabel} (${seenCount})`,
+            cwd,
+        };
+    });
+}
+export function buildPublicWorkspaceOptions(workspaceOptions) {
+    return workspaceOptions.map(({ id, label }) => ({ id, label }));
+}
+export function readSessionWorkspaceConfig(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const data = raw;
+    return {
+        workspaceId: normalizeOptionalString(data.workspaceId),
+        legacyCwd: normalizeOptionalString(data.cwd),
+        model: normalizeOptionalString(data.model),
+    };
+}
+function findWorkspaceByLegacyCwd(workspaceOptions, legacyCwd) {
+    if (!legacyCwd)
+        return undefined;
+    const resolvedLegacyCwd = resolve(legacyCwd);
+    return workspaceOptions.find((workspace) => resolve(workspace.cwd) === resolvedLegacyCwd);
+}
+export function resolveConfiguredWorkspaceCwd(input) {
+    const fallbackCwd = input.workspaceOptions[0]?.cwd ?? resolve(input.defaultCwd);
+    if (!input.config)
+        return fallbackCwd;
+    const legacyWorkspace = findWorkspaceByLegacyCwd(input.workspaceOptions, input.config.legacyCwd);
+    const workspaceId = input.config.workspaceId;
+    if (workspaceId) {
+        const workspace = input.workspaceOptions.find((option) => option.id === workspaceId);
+        if (workspace)
+            return workspace.cwd;
+        if (workspaceId === 'default') {
+            return fallbackCwd;
+        }
+        const legacyWorkspaceMatch = /^workspace-(\d+)$/.exec(workspaceId);
+        if (legacyWorkspaceMatch) {
+            const legacyIndex = Number.parseInt(legacyWorkspaceMatch[1] ?? '', 10) - 1;
+            if (legacyIndex >= 0 && input.workspaceOptions[legacyIndex]) {
+                return input.workspaceOptions[legacyIndex].cwd;
+            }
+        }
+        if (legacyWorkspace)
+            return legacyWorkspace.cwd;
+        throw new ExecutionEnvironmentError(`Workspace ${workspaceId} is not configured on this machine.`, 'The workspace saved for this Canon coding session is no longer configured on this machine.');
+    }
+    if (legacyWorkspace)
+        return legacyWorkspace.cwd;
+    return fallbackCwd;
+}
+export function buildConversationWorktreeSpec(input) {
+    const resolvedWorkspace = resolve(input.workspaceCwd);
+    const baseLabel = sanitizeSegment(basename(resolvedWorkspace) || 'workspace');
+    const workspaceHash = shortHash(resolvedWorkspace);
+    const conversationHash = shortHash(`${input.agentId}:${input.conversationId}`);
+    return {
+        branch: `canon/${baseLabel}-${workspaceHash.slice(0, 6)}-${conversationHash.slice(0, 8)}`,
+        worktreePath: join(WORKTREE_ROOT, baseLabel, workspaceHash, conversationHash),
+    };
+}
+export function prepareConversationEnvironment(input) {
+    const baseCwd = resolve(input.workspaceCwd);
+    const allowWorktrees = input.allowWorktrees === true;
+    if (!allowWorktrees) {
+        return {
+            cwd: baseCwd,
+            baseCwd,
+            mode: 'locked',
+            lockPath: acquireWorkspaceLock({
+                agentId: input.agentId,
+                conversationId: input.conversationId,
+                workspaceCwd: baseCwd,
+            }),
+            reason: 'Worktree isolation is disabled for this host',
+        };
+    }
+    const repoRoot = detectRepoRoot(baseCwd);
+    if (repoRoot) {
+        const spec = buildConversationWorktreeSpec(input);
+        const relativeCwd = relative(repoRoot, baseCwd);
+        const sessionCwd = relativeCwd ? join(spec.worktreePath, relativeCwd) : spec.worktreePath;
+        if (existsSync(spec.worktreePath)) {
+            if (detectRepoRoot(spec.worktreePath)) {
+                return {
+                    cwd: sessionCwd,
+                    baseCwd,
+                    mode: 'worktree',
+                    repoRoot,
+                    branch: spec.branch,
+                    worktreePath: spec.worktreePath,
+                };
+            }
+        }
+        else if (isRepoClean(repoRoot)) {
+            mkdirSync(dirname(spec.worktreePath), { recursive: true });
+            const addArgs = branchExists(repoRoot, spec.branch)
+                ? ['worktree', 'add', spec.worktreePath, spec.branch]
+                : ['worktree', 'add', '-b', spec.branch, spec.worktreePath, 'HEAD'];
+            const addResult = runGit(repoRoot, addArgs);
+            if (addResult.ok && detectRepoRoot(spec.worktreePath)) {
+                return {
+                    cwd: sessionCwd,
+                    baseCwd,
+                    mode: 'worktree',
+                    repoRoot,
+                    branch: spec.branch,
+                    worktreePath: spec.worktreePath,
+                };
+            }
+        }
+    }
+    return {
+        cwd: baseCwd,
+        baseCwd,
+        mode: 'locked',
+        lockPath: acquireWorkspaceLock({
+            agentId: input.agentId,
+            conversationId: input.conversationId,
+            workspaceCwd: baseCwd,
+        }),
+        reason: repoRoot
+            ? 'Base repository is dirty or worktree creation failed'
+            : 'Workspace is not a git repository',
+    };
+}
+export function releaseConversationEnvironment(environment) {
+    if (!environment.lockPath)
+        return;
+    try {
+        unlinkSync(environment.lockPath);
+    }
+    catch {
+        // Ignore lock cleanup failures; stale locks are cleaned up on next acquire.
+    }
+}

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 export { AGENT_CAPABILITIES, } from './types.js';
-export type { AgentCapabilities, AgentClientType, CanonMessage, CanonConversation, AgentContext, MessageCreatedPayload, TypingPayload, PresencePayload, SendMessageOptions, CreateConversationOptions, RegistrationInput, RegistrationResult, RegistrationStatus, StreamingStatus, SetStreamingOptions, SessionControl, SessionState, SessionConfig, AgentRuntime, ModelOption, WorkspaceOption, } from './types.js';
+export type { AgentCapabilities, AgentClientType, CanonMessage, CanonConversation, CanonMessagesPage, AgentContext, MediaAttachment, MediaAttachmentKind, MessageCreatedPayload, TypingPayload, PresencePayload, SendMessageOptions, CreateConversationOptions, RegistrationInput, RegistrationResult, RegistrationStatus, StreamingStatus, SetStreamingOptions, SessionControl, SessionState, SessionConfig, AgentRuntime, ModelOption, WorkspaceOption, } from './types.js';
 export { CanonClient, CanonApiError } from './client.js';
 export { CanonStream } from './stream.js';
 export type { StreamHandler } from './stream.js';
+export type { PolicyRole, ParticipationStyle, RepresentationMode, PermissionLevel, ConversationScope, AgentBehaviorSettings, Participant, Relationship, ContextOverlay, BehaviorProfile, AdmissionPolicy, RuntimeControlPolicy, ActionApprovalPolicy, ParticipationPolicy, WorkSession, ResolvedPolicy, ResolvedTurnEligibility, ResolvedAgentBehaviorPolicy, ParticipationHistoryMessage, ParticipationHistorySnapshot, ParticipationDecisionInput, ParticipationDecision, } from './policy.js';
+export { buildParticipationHistorySnapshot, buildParticipationHistorySnapshots, buildBehaviorPolicyLines, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, evaluateParticipationPolicy, getDefaultParticipationPolicy, resolveAgentBehaviorPolicy, } from './policy.js';
+export { DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, isTurnOpen, normalizeTurnMetadata, normalizeTurnState, resolveTurnMessageSemantics, shouldPromoteConversationMessage, shouldTriggerAgentTurn, } from './turn-protocol.js';
+export type { DeliveryIntent, TurnMessageSemantics, InboundDisposition, TurnLifecycleState, RuntimeCapabilities, TurnState, TurnMetadata, TriggerDecision, } from './turn-protocol.js';
 export { registerAndWaitForApproval } from './registration.js';
 export { ApprovalManager } from './approval-manager.js';
 export { generateApprovalId, buildApprovalRequest, buildApprovalReply, buildApprovalOutcome, parseTextApprovalReply, redactSecrets, } from './approval-format.js';
@@ -12,8 +16,10 @@ export { createStreamingHelper } from './streaming.js';
 export type { RTDBHandle, RTDBRef, ServerTimestamp, StreamingHelperOptions, StreamingNode } from './streaming.js';
 export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive, CANON_DIR, AGENTS_PATH, LOCKS_DIR, } from './agent-profiles.js';
 export type { AgentProfile } from './agent-profiles.js';
-export { resolveCanonAgent, getActiveProfile } from './agent-resolver.js';
+export { resolveCanonAgent, resolveCanonProfile, getActiveProfile } from './agent-resolver.js';
 export type { ResolvedAgent } from './agent-resolver.js';
-export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState } from './rtdb-rest.js';
-export type { SessionStatePayload } from './rtdb-rest.js';
+export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
+export type { ConfiguredWorkspaceOption, ExecutionEnvironmentMode, PreparedExecutionEnvironment, SessionWorkspaceConfig, } from './execution-environment.js';
+export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState, writeTurnState, clearTurnState, } from './rtdb-rest.js';
+export type { SessionStatePayload, TurnStatePayload } from './rtdb-rest.js';
 export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';

package/dist/index.js

@@ -4,6 +4,9 @@ export { AGENT_CAPABILITIES, } from './types.js';
 export { CanonClient, CanonApiError } from './client.js';
 // Stream
 export { CanonStream } from './stream.js';
+export { buildParticipationHistorySnapshot, buildParticipationHistorySnapshots, buildBehaviorPolicyLines, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, evaluateParticipationPolicy, getDefaultParticipationPolicy, resolveAgentBehaviorPolicy, } from './policy.js';
+// Turn protocol
+export { DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, isTurnOpen, normalizeTurnMetadata, normalizeTurnState, resolveTurnMessageSemantics, shouldPromoteConversationMessage, shouldTriggerAgentTurn, } from './turn-protocol.js';
 // Registration
 export { registerAndWaitForApproval } from './registration.js';
 // Approval
@@ -15,8 +18,10 @@ export { createStreamingHelper } from './streaming.js';
 // Agent profiles (loading, locking, resolution)
 export { loadProfiles, isProfileLocked, acquireLock, releaseLock, isProcessAlive, CANON_DIR, AGENTS_PATH, LOCKS_DIR, } from './agent-profiles.js';
 // Agent resolver
-export { resolveCanonAgent, getActiveProfile } from './agent-resolver.js';
+export { resolveCanonAgent, resolveCanonProfile, getActiveProfile } from './agent-resolver.js';
+// Execution environments for host-mode coding sessions
+export { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildConversationWorktreeSpec, buildPublicWorkspaceOptions, buildWorkspaceOptionId, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, ExecutionEnvironmentError, prepareConversationEnvironment, releaseConversationEnvironment, } from './execution-environment.js';
 // RTDB REST helpers (token exchange, session state, generic read/write)
-export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState } from './rtdb-rest.js';
+export { initRTDBAuth, rtdbWrite, rtdbRead, writeSessionState, clearSessionState, writeTurnState, clearTurnState, } from './rtdb-rest.js';
 // Constants
 export { DEFAULT_BASE_URL, DEFAULT_STREAM_URL, DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from './constants.js';