@agent-api/app-engine 0.0.2 → 0.0.3

package/dist/agent.d.ts

@@ -1,2 +1,2 @@
 export { type AgentRunOptions, type AgentTurnEvent, type AgentTurnResult, type LocalToolApprovalRequest, type WorkdirAccessMode, agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, resolveAgentRequestTools, resumeAgentAfterLocalApproval, runAgent, runAgentTurn, } from "./agent/runner.js";
-export { conversationSummary, deleteConversation, getConversation, listConversations, } from "./conversation/index.js";
+export { conversationSummary, deleteConversation, ensureConversation, getConversation, listConversations, startFreshConversation, } from "./conversation/index.js";

package/dist/agent.js

@@ -1,2 +1,2 @@
 export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, resolveAgentRequestTools, resumeAgentAfterLocalApproval, runAgent, runAgentTurn, } from "./agent/runner.js";
-export { conversationSummary, deleteConversation, getConversation, listConversations, } from "./conversation/index.js";
+export { conversationSummary, deleteConversation, ensureConversation, getConversation, listConversations, startFreshConversation, } from "./conversation/index.js";

package/dist/config.d.ts

@@ -25,9 +25,11 @@ export interface CLIConfig {
     profiles: Record<string, Profile>;
 }
 export interface ConversationState {
+    id: string;
     name: string;
     profile: string;
     previousResponseId?: string;
+    createdAt: number;
     updatedAt: number;
 }
 export interface WorkbenchPreferences {
@@ -51,6 +53,8 @@ export declare function activeProfile(profileName?: string): Promise<Profile>;
 export declare function emptyConfig(): CLIConfig;
 export declare function emptyAppConfiguration(): AppConfiguration;
 export declare function emptyConversationConfiguration(): ConversationConfiguration;
+export declare function createConversationID(): string;
+export declare function legacyConversationID(profile: string, name: string): string;
 export declare function loadWorkbenchPreferences(): Promise<WorkbenchPreferences>;
 export declare function updateWorkbenchPreferences(patch: {
     defaultPreset?: string | null | undefined;

package/dist/config.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
 import { ensureRuntime, runtime } from "./runtime/index.js";
 export const defaultBaseURL = "https://api.agentsway.dev";
 export const configFile = "profiles.json";
@@ -25,9 +26,11 @@ const profileSchema = z.object({
     updatedAt: z.number(),
 });
 const conversationSchema = z.object({
+    id: z.string().optional(),
     name: z.string(),
     profile: z.string(),
     previousResponseId: z.string().optional(),
+    createdAt: z.number().optional(),
     updatedAt: z.number(),
 });
 const workbenchPreferencesSchema = z.object({
@@ -88,7 +91,11 @@ export async function loadConversationConfiguration() {
     if (!parsed.success) {
         throw new Error(`Invalid conversation configuration: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
     }
-    return parsed.data;
+    const normalized = normalizeConversationConfiguration(parsed.data);
+    if (normalized.changed) {
+        await saveConversationConfiguration(normalized.config);
+    }
+    return normalized.config;
 }
 export async function saveConversationConfiguration(config) {
     await ensureRuntime();
@@ -126,6 +133,31 @@ export function emptyAppConfiguration() {
 export function emptyConversationConfiguration() {
     return { conversations: {} };
 }
+export function createConversationID() {
+    return `conv_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+}
+export function legacyConversationID(profile, name) {
+    return `conv_${createHash("sha256").update(`${profile}:${name}`).digest("hex").slice(0, 24)}`;
+}
+function normalizeConversationConfiguration(config) {
+    let changed = false;
+    const conversations = {};
+    for (const [key, conversation] of Object.entries(config.conversations)) {
+        const id = conversation.id || legacyConversationID(conversation.profile, conversation.name);
+        const createdAt = conversation.createdAt ?? conversation.updatedAt;
+        if (!conversation.id || !conversation.createdAt)
+            changed = true;
+        conversations[key] = {
+            id,
+            name: conversation.name,
+            profile: conversation.profile,
+            previousResponseId: conversation.previousResponseId,
+            createdAt,
+            updatedAt: conversation.updatedAt,
+        };
+    }
+    return { config: { conversations }, changed };
+}
 export async function loadWorkbenchPreferences() {
     const appConfig = await loadAppConfiguration();
     return appConfig.workbench;

package/dist/conversation/index.d.ts

@@ -11,6 +11,8 @@ export declare function updateConversation(options: {
     profile?: string;
     conversation?: string;
 }, responseID: string): Promise<void>;
+export declare function ensureConversation(name: string, profileName?: string): Promise<ConversationState>;
+export declare function startFreshConversation(name: string, profileName?: string): Promise<ConversationState>;
 export declare function listConversations(profileName?: string): Promise<ConversationState[]>;
 export declare function getConversation(name: string, profileName?: string): Promise<ConversationState>;
 export declare function deleteConversation(name: string, profileName?: string): Promise<void>;

package/dist/conversation/index.js

@@ -1,4 +1,4 @@
-import { activeProfile, loadConversationConfiguration, saveConversationConfiguration } from "../config.js";
+import { activeProfile, createConversationID, loadConversationConfiguration, saveConversationConfiguration, } from "../config.js";
 export function conversationKey(profile, name) {
     return `${profile}:${name}`;
 }
@@ -18,14 +18,53 @@ export async function updateConversation(options, responseID) {
         return;
     const profile = await activeProfile(options.profile);
     const config = await loadConversationConfiguration();
+    const key = conversationKey(profile.name, options.conversation);
+    const existing = config.conversations[key];
+    const now = Math.floor(Date.now() / 1000);
     config.conversations[conversationKey(profile.name, options.conversation)] = {
+        id: existing?.id ?? createConversationID(),
         name: options.conversation,
         profile: profile.name,
         previousResponseId: responseID,
-        updatedAt: Math.floor(Date.now() / 1000),
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
     };
     await saveConversationConfiguration(config);
 }
+export async function ensureConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConversationConfiguration();
+    const key = conversationKey(profile.name, name);
+    const existing = config.conversations[key];
+    if (existing)
+        return existing;
+    const now = Math.floor(Date.now() / 1000);
+    const conversation = {
+        id: createConversationID(),
+        name,
+        profile: profile.name,
+        createdAt: now,
+        updatedAt: now,
+    };
+    config.conversations[key] = conversation;
+    await saveConversationConfiguration(config);
+    return conversation;
+}
+export async function startFreshConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConversationConfiguration();
+    const now = Math.floor(Date.now() / 1000);
+    const conversation = {
+        id: createConversationID(),
+        name,
+        profile: profile.name,
+        createdAt: now,
+        updatedAt: now,
+    };
+    config.conversations[conversationKey(profile.name, name)] = conversation;
+    await saveConversationConfiguration(config);
+    return conversation;
+}
 export async function listConversations(profileName) {
     const profile = await activeProfile(profileName);
     const config = await loadConversationConfiguration();
@@ -50,5 +89,5 @@ export async function deleteConversation(name, profileName) {
 export function conversationSummary(conversation) {
     const updated = new Date(conversation.updatedAt * 1000).toISOString();
     const response = conversation.previousResponseId ? ` response=${conversation.previousResponseId}` : "";
-    return `${conversation.name}\t${conversation.profile}\t${updated}${response}`;
+    return `${conversation.name}\t${conversation.profile}\t${updated}\t${conversation.id}${response}`;
 }

package/dist/engine/agent-engine.d.ts

@@ -12,6 +12,7 @@ export interface AgentEngineApp {
     subscribe(listener: () => void): () => void;
     dispatch(action: WorkbenchAction): void;
     maybeCheckForUpdate(options?: AgentEngineLifecycleOptions): Promise<void>;
+    loadInitialConversation(options?: AgentEngineLifecycleOptions): Promise<void>;
     loadInitialSettings(options?: AgentEngineLifecycleOptions): Promise<void>;
     loadWorkdir(path?: string, options?: AgentEngineLifecycleOptions): Promise<void>;
     refreshAuth(profile?: string, options?: AgentEngineLifecycleOptions): Promise<void>;

package/dist/engine/agent-engine.js

@@ -35,6 +35,37 @@ export function createAgentEngine(options) {
         const effects = await session.lifecycle.maybeCheckForUpdate();
         runLifecycleEffects(effects, lifecycleOptions);
     }
+    async function loadInitialConversation(lifecycleOptions = {}) {
+        try {
+            const state = session.engine.snapshot();
+            const conversation = await session.conversation.resolveConversation(state.currentConversation, options.baseOptions.profile);
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({
+                type: "conversation.set",
+                id: conversation.id,
+                name: conversation.name,
+                previousResponseId: conversation.previousResponseId,
+                status: conversation.status,
+            });
+            if (conversation.previousResponseId) {
+                session.engine.dispatch({
+                    type: "message.add",
+                    role: "system",
+                    text: `Continuing conversation "${conversation.name}" from ${conversation.previousResponseId}. Use /new to start without prior context.`,
+                });
+            }
+        }
+        catch (error) {
+            if (lifecycleOptions.isMounted && !lifecycleOptions.isMounted())
+                return;
+            session.engine.dispatch({
+                type: "activity.add",
+                level: "warning",
+                text: `Conversation state unavailable: ${userFacingError(error)}`,
+            });
+        }
+    }
     async function loadInitialSettings(lifecycleOptions = {}) {
         try {
             const settings = await session.settings.loadInitial({
@@ -127,6 +158,7 @@ export function createAgentEngine(options) {
         subscribe: session.engine.subscribe,
         dispatch: session.engine.dispatch,
         maybeCheckForUpdate,
+        loadInitialConversation,
         loadInitialSettings,
         loadWorkdir,
         refreshAuth,

package/dist/engine/index.d.ts

@@ -1,7 +1,7 @@
 export type { AgentEngineApp, AgentEngineAppOptions, AgentEngineLifecycleOptions, } from "./agent-engine.js";
 export { createAgentEngine, } from "./agent-engine.js";
 export type { AgentRunOptions, AgentTurnEvent, LocalToolApprovalRequest, WorkdirAccessMode, } from "../agent.js";
-export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, } from "../agent.js";
+export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, ensureConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, startFreshConversation, } from "../agent.js";
 export type { ChatOptions } from "../chat-options.js";
 export { normalizeChatOptions } from "../chat-options.js";
 export type { AgentEngineServices } from "./services.js";

package/dist/engine/index.js

@@ -1,5 +1,5 @@
 export { createAgentEngine, } from "./agent-engine.js";
-export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, } from "../agent.js";
+export { agentResponseFailureMessage, agentTurnEventFromStreamEvent, clearPresetToolCatalogCache, conversationSummary, deleteConversation, ensureConversation, getConversation, isAvailablePreset, listAvailablePresets, listConversations, resumeAgentAfterLocalApproval, runAgent, resolveAgentRequestTools, runAgentTurn, startFreshConversation, } from "../agent.js";
 export { normalizeChatOptions } from "../chat-options.js";
 export { defaultBaseURL } from "../config.js";
 export { activeProfile, loadAppConfiguration, loadConfig, loadConversationConfiguration, loadWorkbenchPreferences, redactSecret, saveAppConfiguration, saveConfig, saveConversationConfiguration, updateWorkbenchPreferences, } from "../config.js";

package/dist/workbench/command-controller.js

@@ -32,7 +32,7 @@ export function createWorkbenchCommandController(options) {
                     await startNewConversation(command.name);
                     return;
                 case "switch_conversation":
-                    switchConversation(command.name);
+                    await switchConversation(command.name);
                     return;
                 case "list_conversations":
                     await showConversations();
@@ -278,17 +278,29 @@ export function createWorkbenchCommandController(options) {
     async function startNewConversation(name) {
         const conversation = await options.conversationController.startNewConversation(name, options.options.profile);
         dispatch({ type: "messages.clear" });
-        dispatch({ type: "conversation.set", name: conversation.name });
+        dispatch({
+            type: "conversation.set",
+            id: conversation.id,
+            name: conversation.name,
+            previousResponseId: conversation.previousResponseId,
+            status: conversation.status,
+        });
         dispatch({
             type: "message.add",
             role: "system",
             text: conversation.message,
         });
     }
-    function switchConversation(name) {
-        const conversation = options.conversationController.switchConversation(name);
+    async function switchConversation(name) {
+        const conversation = await options.conversationController.switchConversation(name, options.options.profile);
         dispatch({ type: "messages.clear" });
-        dispatch({ type: "conversation.set", name: conversation.name });
+        dispatch({
+            type: "conversation.set",
+            id: conversation.id,
+            name: conversation.name,
+            previousResponseId: conversation.previousResponseId,
+            status: conversation.status,
+        });
         dispatch({
             type: "message.add",
             role: "system",

package/dist/workbench/conversation-controller.d.ts

@@ -1,14 +1,9 @@
 import { mkdir, writeFile } from "node:fs/promises";
-import { deleteConversation, listConversations } from "../agent.js";
+import { deleteConversation, ensureConversation, listConversations, startFreshConversation } from "../agent.js";
 export interface WorkbenchConversationController {
-    startNewConversation(name: string | undefined, profileName?: string): Promise<{
-        name: string;
-        message: string;
-    }>;
-    switchConversation(name: string): {
-        name: string;
-        message: string;
-    };
+    resolveConversation(name: string, profileName?: string): Promise<ConversationSelection>;
+    startNewConversation(name: string | undefined, profileName?: string): Promise<ConversationSelection>;
+    switchConversation(name: string, profileName?: string): Promise<ConversationSelection>;
     listConversations(profileName?: string): Promise<string>;
     exportTranscript(input: {
         path?: string;
@@ -16,6 +11,13 @@ export interface WorkbenchConversationController {
         conversation: string;
     }): Promise<string>;
 }
+export interface ConversationSelection {
+    id: string;
+    name: string;
+    previousResponseId?: string;
+    status: "fresh" | "continued";
+    message: string;
+}
 export interface WorkbenchConversationControllerOptions {
     deleteConversationImpl?: typeof deleteConversation;
     listConversationsImpl?: typeof listConversations;
@@ -23,6 +25,8 @@ export interface WorkbenchConversationControllerOptions {
     writeFileImpl?: typeof writeFile;
     now?: () => Date;
     dataDir?: string;
+    ensureConversationImpl?: typeof ensureConversation;
+    startFreshConversationImpl?: typeof startFreshConversation;
 }
 export declare function createWorkbenchConversationController(options?: WorkbenchConversationControllerOptions): WorkbenchConversationController;
 export declare function defaultTranscriptExportPath(conversation: string, options?: {

package/dist/workbench/conversation-controller.js

@@ -1,27 +1,31 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { conversationSummary, deleteConversation, listConversations, } from "../agent.js";
+import { conversationSummary, deleteConversation, ensureConversation, listConversations, startFreshConversation, } from "../agent.js";
 import { runtime } from "../runtime/index.js";
 export function createWorkbenchConversationController(options = {}) {
     const deleteConversationImpl = options.deleteConversationImpl ?? deleteConversation;
     const listConversationsImpl = options.listConversationsImpl ?? listConversations;
+    const ensureConversationImpl = options.ensureConversationImpl ?? ensureConversation;
+    const startFreshConversationImpl = options.startFreshConversationImpl ?? startFreshConversation;
     const mkdirImpl = options.mkdirImpl ?? mkdir;
     const writeFileImpl = options.writeFileImpl ?? writeFile;
     const now = options.now ?? (() => new Date());
     return {
+        async resolveConversation(name, profileName) {
+            const conversation = await ensureConversationImpl(name, profileName);
+            return conversationSelection(conversation, `Conversation "${conversation.name}" is ${conversation.previousResponseId ? `continuing from ${conversation.previousResponseId}` : "fresh"}.`);
+        },
         async startNewConversation(name, profileName) {
-            const conversation = name || createConversationName(now());
-            await deleteConversationImpl(conversation, profileName);
-            return {
-                name: conversation,
-                message: `Started fresh conversation "${conversation}".`,
-            };
+            const nameToUse = name || createConversationName(now());
+            await deleteConversationImpl(nameToUse, profileName);
+            const conversation = await startFreshConversationImpl(nameToUse, profileName);
+            return conversationSelection(conversation, `Started fresh conversation "${conversation.name}" (${conversation.id}).`);
         },
-        switchConversation(name) {
-            return {
-                name,
-                message: `Switched to conversation "${name}". Future turns will continue this handle when history exists.`,
-            };
+        async switchConversation(name, profileName) {
+            const conversation = await ensureConversationImpl(name, profileName);
+            return conversationSelection(conversation, conversation.previousResponseId
+                ? `Switched to conversation "${name}" (${conversation.id}). Continuing from ${conversation.previousResponseId}.`
+                : `Switched to fresh conversation "${name}" (${conversation.id}).`);
         },
         async listConversations(profileName) {
             const conversations = await listConversationsImpl(profileName);
@@ -42,6 +46,17 @@ export function createWorkbenchConversationController(options = {}) {
         },
     };
 }
+function conversationSelection(conversation, message) {
+    const selection = {
+        id: conversation.id,
+        name: conversation.name,
+        status: conversation.previousResponseId ? "continued" : "fresh",
+        message,
+    };
+    if (conversation.previousResponseId)
+        selection.previousResponseId = conversation.previousResponseId;
+    return selection;
+}
 export function defaultTranscriptExportPath(conversation, options = {}) {
     const safeConversation = conversation.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "conversation";
     const stamp = (options.now?.() ?? new Date()).toISOString().replace(/[:.]/g, "-");

package/dist/workbench/render-model.d.ts

@@ -11,6 +11,9 @@ export interface WorkbenchRenderModel {
         accessMode: string;
         contextEnabled: boolean;
         conversation: string;
+        conversationId: string;
+        conversationPreviousResponseId: string;
+        conversationStatus: "fresh" | "continued" | "unknown";
         model: string;
         pendingLocalLabel: string;
         preset: string;

package/dist/workbench/render-model.js

@@ -28,6 +28,9 @@ export function buildWorkbenchRenderModel(input) {
             accessMode: input.state.accessMode,
             contextEnabled: input.state.contextEnabled,
             conversation: input.state.currentConversation,
+            conversationId: input.state.conversationId || "unresolved",
+            conversationPreviousResponseId: input.state.conversationPreviousResponseId || "",
+            conversationStatus: input.state.conversationStatus,
             model: input.state.runModel || "auto",
             pendingLocalLabel: pendingLocalLabel(input.state),
             preset: input.state.runPreset || "none",

package/dist/workbench/state.d.ts

@@ -34,6 +34,9 @@ export interface WorkbenchState {
     activeAssistantMessageId: string | null;
     pendingLocalTool: LocalToolApproval | null;
     accessMode: WorkdirAccessMode;
+    conversationId?: string;
+    conversationPreviousResponseId?: string;
+    conversationStatus: "fresh" | "continued" | "unknown";
     currentConversation: string;
     runPreset?: string;
     runModel?: string;
@@ -87,7 +90,10 @@ export type WorkbenchAction = {
     mode: WorkdirAccessMode;
 } | {
     type: "conversation.set";
+    id?: string;
     name: string;
+    previousResponseId?: string;
+    status?: "fresh" | "continued" | "unknown";
 } | {
     type: "settings.set";
     settings: Partial<Pick<WorkbenchState, "runPreset" | "runModel" | "renderMode" | "defaultPreset" | "shellIsolation">>;

package/dist/workbench/state.js

@@ -13,6 +13,9 @@ export function createInitialWorkbenchState(options) {
         activeAssistantMessageId: null,
         pendingLocalTool: null,
         accessMode,
+        conversationId: undefined,
+        conversationPreviousResponseId: undefined,
+        conversationStatus: "unknown",
         currentConversation: options.conversation || "default",
         runPreset: options.preset,
         runModel: options.model,
@@ -132,8 +135,11 @@ export function workbenchReducer(state, action) {
         case "conversation.set":
             return {
                 ...state,
+                conversationId: action.id,
                 currentConversation: action.name,
-                activities: [...state.activities, newActivity("info", `Conversation: ${action.name}`)].slice(-20),
+                conversationPreviousResponseId: action.previousResponseId,
+                conversationStatus: action.status ?? (action.previousResponseId ? "continued" : "fresh"),
+                activities: [...state.activities, newActivity("info", conversationActivityText(action))].slice(-20),
             };
         case "settings.set":
             return {
@@ -144,6 +150,10 @@ export function workbenchReducer(state, action) {
             return state;
     }
 }
+function conversationActivityText(action) {
+    const suffix = action.previousResponseId ? ` continues ${action.previousResponseId}` : action.status === "fresh" ? " fresh" : "";
+    return `Conversation: ${action.name}${suffix}`;
+}
 function setLocalAccess(state, mode) {
     return {
         ...state,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-api/app-engine",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Renderer-neutral application engine for Agent API apps",
   "license": "MIT",
   "homepage": "https://github.com/scalebox-dev/agent-tui#readme",