@openadapter/koda 1.0.0-beta.3

package/dist/core/agent-session-runtime.d.ts

@@ -0,0 +1,116 @@
+import type { AgentSession } from "./agent-session.ts";
+import type { AgentSessionRuntimeDiagnostic, AgentSessionServices } from "./agent-session-services.ts";
+import type { ReplacedSessionContext, SessionStartEvent } from "./extensions/index.ts";
+import type { CreateAgentSessionResult } from "./sdk.ts";
+import { SessionManager } from "./session-manager.ts";
+/**
+ * Result returned by runtime creation.
+ *
+ * The caller gets the created session, its cwd-bound services, and all
+ * diagnostics collected during setup.
+ */
+export interface CreateAgentSessionRuntimeResult extends CreateAgentSessionResult {
+    services: AgentSessionServices;
+    diagnostics: AgentSessionRuntimeDiagnostic[];
+}
+/**
+ * Creates a full runtime for a target cwd and session manager.
+ *
+ * The factory closes over process-global fixed inputs, recreates cwd-bound
+ * services for the effective cwd, resolves session options against those
+ * services, and finally creates the AgentSession.
+ */
+export type CreateAgentSessionRuntimeFactory = (options: {
+    cwd: string;
+    agentDir: string;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+}) => Promise<CreateAgentSessionRuntimeResult>;
+/**
+ * Thrown when /import references a JSONL file path that does not exist.
+ */
+export declare class SessionImportFileNotFoundError extends Error {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+/**
+ * Owns the current AgentSession plus its cwd-bound services.
+ *
+ * Session replacement methods tear down the current runtime first, then create
+ * and apply the next runtime. If creation fails, the error is propagated to the
+ * caller. The caller is responsible for user-facing error handling.
+ */
+export declare class AgentSessionRuntime {
+    private rebindSession?;
+    private beforeSessionInvalidate?;
+    private _session;
+    private _services;
+    private readonly createRuntime;
+    private _diagnostics;
+    private _modelFallbackMessage?;
+    constructor(_session: AgentSession, _services: AgentSessionServices, createRuntime: CreateAgentSessionRuntimeFactory, _diagnostics?: AgentSessionRuntimeDiagnostic[], _modelFallbackMessage?: string);
+    get services(): AgentSessionServices;
+    get session(): AgentSession;
+    get cwd(): string;
+    get diagnostics(): readonly AgentSessionRuntimeDiagnostic[];
+    get modelFallbackMessage(): string | undefined;
+    setRebindSession(rebindSession?: (session: AgentSession) => Promise<void>): void;
+    /**
+     * Set a synchronous callback that runs after `session_shutdown` handlers finish
+     * but before the current session is invalidated.
+     *
+     * This is for host-owned UI teardown that must not yield to the event loop,
+     * such as detaching extension-provided TUI components before the old extension
+     * context becomes stale.
+     */
+    setBeforeSessionInvalidate(beforeSessionInvalidate?: () => void): void;
+    private emitBeforeSwitch;
+    private emitBeforeFork;
+    private teardownCurrent;
+    private apply;
+    private finishSessionReplacement;
+    switchSession(sessionPath: string, options?: {
+        cwdOverride?: string;
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+    }): Promise<{
+        cancelled: boolean;
+    }>;
+    newSession(options?: {
+        parentSession?: string;
+        setup?: (sessionManager: SessionManager) => Promise<void>;
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+    }): Promise<{
+        cancelled: boolean;
+    }>;
+    fork(entryId: string, options?: {
+        position?: "before" | "at";
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+    }): Promise<{
+        cancelled: boolean;
+        selectedText?: string;
+    }>;
+    /**
+     * Import a session JSONL file and switch runtime state to the imported session.
+     *
+     * @returns `{ cancelled: true }` when cancelled by `session_before_switch`, otherwise `{ cancelled: false }`.
+     * @throws {SessionImportFileNotFoundError} When the input path does not exist.
+     * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
+     */
+    importFromJsonl(inputPath: string, cwdOverride?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    dispose(): Promise<void>;
+}
+/**
+ * Create the initial runtime from a runtime factory and initial session target.
+ *
+ * The same factory is stored on the returned AgentSessionRuntime and reused for
+ * later /new, /resume, /fork, and import flows.
+ */
+export declare function createAgentSessionRuntime(createRuntime: CreateAgentSessionRuntimeFactory, options: {
+    cwd: string;
+    agentDir: string;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+}): Promise<AgentSessionRuntime>;
+export { type AgentSessionRuntimeDiagnostic, type AgentSessionServices, type CreateAgentSessionFromServicesOptions, type CreateAgentSessionServicesOptions, createAgentSessionFromServices, createAgentSessionServices, } from "./agent-session-services.ts";

package/dist/core/agent-session-runtime.js

@@ -0,0 +1 @@
+var v=Object.defineProperty;var l=(r,e)=>v(r,"name",{value:e,configurable:!0});import{copyFileSync as y,existsSync as m,mkdirSync as F}from"node:fs";import{basename as _,join as b,resolve as R}from"node:path";import{resolvePath as k}from"../utils/paths.js";import{emitSessionShutdownEvent as p}from"./extensions/runner.js";import{assertSessionCwdExists as g}from"./session-cwd.js";import{SessionManager as h}from"./session-manager.js";class M extends Error{static{l(this,"SessionImportFileNotFoundError")}filePath;constructor(e){super(`File not found: ${e}`),this.name="SessionImportFileNotFoundError",this.filePath=e}}function D(r){return typeof r=="string"?r:r.filter(e=>e.type==="text"&&typeof e.text=="string").map(e=>e.text).join("")}l(D,"extractUserMessageText");class x{static{l(this,"AgentSessionRuntime")}rebindSession;beforeSessionInvalidate;_session;_services;createRuntime;_diagnostics;_modelFallbackMessage;constructor(e,s,t,n=[],i){this._session=e,this._services=s,this.createRuntime=t,this._diagnostics=n,this._modelFallbackMessage=i}get services(){return this._services}get session(){return this._session}get cwd(){return this._services.cwd}get diagnostics(){return this._diagnostics}get modelFallbackMessage(){return this._modelFallbackMessage}setRebindSession(e){this.rebindSession=e}setBeforeSessionInvalidate(e){this.beforeSessionInvalidate=e}async emitBeforeSwitch(e,s){const t=this.session.extensionRunner;return t.hasHandlers("session_before_switch")?{cancelled:(await t.emit({type:"session_before_switch",reason:e,targetSessionFile:s}))?.cancel===!0}:{cancelled:!1}}async emitBeforeFork(e,s){const t=this.session.extensionRunner;return t.hasHandlers("session_before_fork")?{cancelled:(await t.emit({type:"session_before_fork",entryId:e,...s}))?.cancel===!0}:{cancelled:!1}}async teardownCurrent(e,s){await p(this.session.extensionRunner,{type:"session_shutdown",reason:e,targetSessionFile:s}),this.beforeSessionInvalidate?.(),this.session.dispose()}apply(e){this._session=e.session,this._services=e.services,this._diagnostics=e.diagnostics,this._modelFallbackMessage=e.modelFallbackMessage}async finishSessionReplacement(e){this.rebindSession&&await this.rebindSession(this.session),e&&await e(this.session.createReplacedSessionContext())}async switchSession(e,s){const t=await this.emitBeforeSwitch("resume",e);if(t.cancelled)return t;const n=this.session.sessionFile,i=h.open(e,void 0,s?.cwdOverride);return g(i,this.cwd),await this.teardownCurrent("resume",i.getSessionFile()),this.apply(await this.createRuntime({cwd:i.getCwd(),agentDir:this.services.agentDir,sessionManager:i,sessionStartEvent:{type:"session_start",reason:"resume",previousSessionFile:n}})),await this.finishSessionReplacement(s?.withSession),{cancelled:!1}}async newSession(e){const s=await this.emitBeforeSwitch("new");if(s.cancelled)return s;const t=this.session.sessionFile,n=this.session.sessionManager.getSessionDir(),i=h.create(this.cwd,n);return e?.parentSession&&i.newSession({parentSession:e.parentSession}),await this.teardownCurrent("new",i.getSessionFile()),this.apply(await this.createRuntime({cwd:this.cwd,agentDir:this.services.agentDir,sessionManager:i,sessionStartEvent:{type:"session_start",reason:"new",previousSessionFile:t}})),e?.setup&&(await e.setup(this.session.sessionManager),this.session.agent.state.messages=this.session.sessionManager.buildSessionContext().messages),await this.finishSessionReplacement(e?.withSession),{cancelled:!1}}async fork(e,s){const t=s?.position??"before";if((await this.emitBeforeFork(e,{position:t})).cancelled)return{cancelled:!0};let i,c;const o=this.session.sessionManager.getEntry(e);if(!o)throw new Error("Invalid entry ID for forking");if(t==="at")i=o.id;else{if(o.type!=="message"||o.message.role!=="user")throw new Error("Invalid entry ID for forking");i=o.parentId,c=D(o.message.content)}const a=this.session.sessionFile;if(this.session.sessionManager.isPersisted()){const w=this.session.sessionFile;if(!w)throw new Error("Persisted session is missing a session file");const S=this.session.sessionManager.getSessionDir();if(!i){const u=h.create(this.cwd,S);return u.newSession({parentSession:w}),await this.teardownCurrent("fork",u.getSessionFile()),this.apply(await this.createRuntime({cwd:this.cwd,agentDir:this.services.agentDir,sessionManager:u,sessionStartEvent:{type:"session_start",reason:"fork",previousSessionFile:a}})),await this.finishSessionReplacement(s?.withSession),{cancelled:!1,selectedText:c}}const f=h.open(w,S);if(!f.createBranchedSession(i))throw new Error("Failed to create forked session");return await this.teardownCurrent("fork",f.getSessionFile()),this.apply(await this.createRuntime({cwd:f.getCwd(),agentDir:this.services.agentDir,sessionManager:f,sessionStartEvent:{type:"session_start",reason:"fork",previousSessionFile:a}})),await this.finishSessionReplacement(s?.withSession),{cancelled:!1,selectedText:c}}const d=this.session.sessionManager;return i?d.createBranchedSession(i):d.newSession({parentSession:this.session.sessionFile}),await this.teardownCurrent("fork",d.getSessionFile()),this.apply(await this.createRuntime({cwd:this.cwd,agentDir:this.services.agentDir,sessionManager:d,sessionStartEvent:{type:"session_start",reason:"fork",previousSessionFile:a}})),await this.finishSessionReplacement(s?.withSession),{cancelled:!1,selectedText:c}}async importFromJsonl(e,s){const t=k(e);if(!m(t))throw new M(t);const n=this.session.sessionManager.getSessionDir();m(n)||F(n,{recursive:!0});const i=b(n,_(t)),c=await this.emitBeforeSwitch("resume",i);if(c.cancelled)return c;const o=this.session.sessionFile;R(i)!==t&&y(t,i);const a=h.open(i,n,s);return g(a,this.cwd),await this.teardownCurrent("resume",a.getSessionFile()),this.apply(await this.createRuntime({cwd:a.getCwd(),agentDir:this.services.agentDir,sessionManager:a,sessionStartEvent:{type:"session_start",reason:"resume",previousSessionFile:o}})),await this.finishSessionReplacement(),{cancelled:!1}}async dispose(){await p(this.session.extensionRunner,{type:"session_shutdown",reason:"quit"}),this.beforeSessionInvalidate?.(),this.session.dispose()}}async function N(r,e){g(e.sessionManager,e.cwd);const s=await r(e);return new x(s.session,s.services,r,s.diagnostics,s.modelFallbackMessage)}l(N,"createAgentSessionRuntime");import{createAgentSessionFromServices as J,createAgentSessionServices as L}from"./agent-session-services.js";export{x as AgentSessionRuntime,M as SessionImportFileNotFoundError,J as createAgentSessionFromServices,N as createAgentSessionRuntime,L as createAgentSessionServices};

package/dist/core/agent-session-services.d.ts

@@ -0,0 +1,86 @@
+import type { ThinkingLevel } from "@openadapter/koda-agent-core";
+import type { Model } from "@openadapter/koda-ai";
+import { AuthStorage } from "./auth-storage.ts";
+import type { SessionStartEvent, ToolDefinition } from "./extensions/index.ts";
+import { ModelRegistry } from "./model-registry.ts";
+import { type DefaultResourceLoaderOptions, type ResourceLoader } from "./resource-loader.ts";
+import { type CreateAgentSessionOptions, type CreateAgentSessionResult } from "./sdk.ts";
+import type { SessionManager } from "./session-manager.ts";
+import { SettingsManager } from "./settings-manager.ts";
+/**
+ * Non-fatal issues collected while creating services or sessions.
+ *
+ * Runtime creation returns diagnostics to the caller instead of printing or
+ * exiting. The app layer decides whether warnings should be shown and whether
+ * errors should abort startup.
+ */
+export interface AgentSessionRuntimeDiagnostic {
+    type: "info" | "warning" | "error";
+    message: string;
+}
+/**
+ * Inputs for creating cwd-bound runtime services.
+ *
+ * These services are recreated whenever the effective session cwd changes.
+ * CLI-provided resource paths should be resolved to absolute paths before they
+ * reach this function, so later cwd switches do not reinterpret them.
+ */
+export interface CreateAgentSessionServicesOptions {
+    cwd: string;
+    agentDir?: string;
+    authStorage?: AuthStorage;
+    settingsManager?: SettingsManager;
+    modelRegistry?: ModelRegistry;
+    extensionFlagValues?: Map<string, boolean | string>;
+    resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "cwd" | "agentDir" | "settingsManager">;
+}
+/**
+ * Inputs for creating an AgentSession from already-created services.
+ *
+ * Use this after services exist and any cwd-bound model/tool/session options
+ * have been resolved against those services.
+ */
+export interface CreateAgentSessionFromServicesOptions {
+    services: AgentSessionServices;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+    model?: Model<any>;
+    thinkingLevel?: ThinkingLevel;
+    scopedModels?: Array<{
+        model: Model<any>;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    tools?: string[];
+    excludeTools?: CreateAgentSessionOptions["excludeTools"];
+    noTools?: CreateAgentSessionOptions["noTools"];
+    customTools?: ToolDefinition[];
+}
+/**
+ * Coherent cwd-bound runtime services for one effective session cwd.
+ *
+ * This is infrastructure only. The AgentSession itself is created separately so
+ * session options can be resolved against these services first.
+ */
+export interface AgentSessionServices {
+    cwd: string;
+    agentDir: string;
+    authStorage: AuthStorage;
+    settingsManager: SettingsManager;
+    modelRegistry: ModelRegistry;
+    resourceLoader: ResourceLoader;
+    diagnostics: AgentSessionRuntimeDiagnostic[];
+}
+/**
+ * Create cwd-bound runtime services.
+ *
+ * Returns services plus diagnostics. It does not create an AgentSession.
+ */
+export declare function createAgentSessionServices(options: CreateAgentSessionServicesOptions): Promise<AgentSessionServices>;
+/**
+ * Create an AgentSession from previously created services.
+ *
+ * This keeps session creation separate from service creation so callers can
+ * resolve model, thinking, tools, and other session inputs against the target
+ * cwd before constructing the session.
+ */
+export declare function createAgentSessionFromServices(options: CreateAgentSessionFromServicesOptions): Promise<CreateAgentSessionResult>;

package/dist/core/agent-session-services.js

@@ -0,0 +1 @@
+var y=Object.defineProperty;var c=(e,t)=>y(e,"name",{value:t,configurable:!0});import{join as u}from"node:path";import{getAgentDir as x}from"../config.js";import{resolvePath as m}from"../utils/paths.js";import{AuthStorage as S}from"./auth-storage.js";import{ModelRegistry as p}from"./model-registry.js";import{DefaultResourceLoader as M}from"./resource-loader.js";import{createAgentSession as R}from"./sdk.js";import{SettingsManager as w}from"./settings-manager.js";function E(e,t){if(!t)return[];const s=[],i=e.getExtensions(),g=new Map;for(const r of i.extensions)for(const[n,a]of r.flags)g.set(n,{type:a.type});const o=[];for(const[r,n]of t){const a=g.get(r);if(!a){o.push(r);continue}if(a.type==="boolean"){i.runtime.flagValues.set(r,!0);continue}if(typeof n=="string"){i.runtime.flagValues.set(r,n);continue}s.push({type:"error",message:`Extension flag "--${r}" requires a value`})}return o.length>0&&s.push({type:"error",message:`Unknown option${o.length===1?"":"s"}: ${o.map(r=>`--${r}`).join(", ")}`}),s}c(E,"applyExtensionFlagValues");async function V(e){const t=m(e.cwd),s=e.agentDir?m(e.agentDir):x(),i=e.authStorage??S.create(u(s,"auth.json")),g=e.settingsManager??w.create(t,s),o=e.modelRegistry??p.create(i,u(s,"models.json")),r=new M({...e.resourceLoaderOptions??{},cwd:t,agentDir:s,settingsManager:g});await r.reload();const n=[],a=r.getExtensions();for(const{name:f,config:d,extensionPath:h}of a.runtime.pendingProviderRegistrations)try{o.registerProvider(f,d)}catch(l){const v=l instanceof Error?l.message:String(l);n.push({type:"error",message:`Extension "${h}" error: ${v}`})}return a.runtime.pendingProviderRegistrations=[],n.push(...E(r,e.extensionFlagValues)),{cwd:t,agentDir:s,authStorage:i,settingsManager:g,modelRegistry:o,resourceLoader:r,diagnostics:n}}c(V,"createAgentSessionServices");async function b(e){return R({cwd:e.services.cwd,agentDir:e.services.agentDir,authStorage:e.services.authStorage,settingsManager:e.services.settingsManager,modelRegistry:e.services.modelRegistry,resourceLoader:e.services.resourceLoader,sessionManager:e.sessionManager,model:e.model,thinkingLevel:e.thinkingLevel,scopedModels:e.scopedModels,tools:e.tools,excludeTools:e.excludeTools,noTools:e.noTools,customTools:e.customTools,sessionStartEvent:e.sessionStartEvent})}c(b,"createAgentSessionFromServices");export{b as createAgentSessionFromServices,V as createAgentSessionServices};