@borgee/agents-host 0.2.101 → 0.2.110

package/dist/policy/copilot-permission.js

@@ -1,6 +1,5 @@
 import { summarizeError } from '../debug.js';
 const LEGACY_MISSING_ALLOW_OPTION_MESSAGE = 'Copilot ACP requested permission but did not offer an allow option';
-const SDK_APPROVE_FOR_SESSION_OPTION_ID = 'sdk-approve-for-session';
 const SDK_APPROVE_ONCE_OPTION_ID = 'sdk-approve-once';
 const SDK_REJECT_OPTION_ID = 'sdk-reject';
 function legacySelectPermissionOption(options) {
@@ -279,12 +278,8 @@ export function resolveCopilotSdkPermissionResponse(context) {
             feedback: 'Managed policy requires interactive approval, which this hosted runtime cannot provide.',
         };
     }
+    // Session grants bypass subsequent host policy checks; approve each SDK request independently.
     const options = [
-        {
-            optionId: SDK_APPROVE_FOR_SESSION_OPTION_ID,
-            name: 'Allow for this session',
-            kind: 'allow_always',
-        },
         {
             optionId: SDK_APPROVE_ONCE_OPTION_ID,
             name: 'Allow once',
@@ -312,8 +307,6 @@ export function resolveCopilotSdkPermissionResponse(context) {
         return { kind: 'reject' };
     }
     switch (response.outcome.optionId) {
-        case SDK_APPROVE_FOR_SESSION_OPTION_ID:
-            return { kind: 'approve-for-session' };
         case SDK_APPROVE_ONCE_OPTION_ID:
             return { kind: 'approve-once' };
         default:

package/dist/providers/copilot/sdk-session.js

@@ -836,7 +836,7 @@ export class CopilotSdkSessionAdapter {
             this.discardAutonomousTurn(turn);
             return;
         }
-        if (event.type === 'assistant.idle') {
+        if (event.type === 'assistant.idle' || event.type === 'session.idle') {
             this.finishAutonomousTurn(turn);
         }
     }
@@ -992,6 +992,10 @@ export class CopilotSdkSessionAdapter {
                 turn.reject(new Error(event.data.message));
                 return;
             }
+            case 'session.idle': {
+                this.finishActiveTurn(false);
+                return;
+            }
             case 'assistant.idle': {
                 this.finishActiveTurn(event.data.aborted === true);
                 return;
@@ -1172,6 +1176,9 @@ export class CopilotSdkSessionAdapter {
             case 'tool.execution_start':
             case 'tool.execution_complete':
                 return event.data.turnId ?? this.currentRootTurnId;
+            case 'session.idle':
+                // Session idle is terminal only after the owned root turn has ended.
+                return this.currentRootTurnId ? undefined : this.lastRootTurnId;
             case 'assistant.usage':
             case 'assistant.idle':
                 return this.currentRootTurnId ?? this.lastRootTurnId;

package/dist/providers/create-provider.js

@@ -1,3 +1,7 @@
+import { join } from 'node:path';
+import { configureHostedNativeSession, createHostedNativeProvider } from '../native-providers.js';
+import { createSessionOwnershipLock, readProtectedCodexSessions } from './normalized/session-ownership.js';
+import { NormalizedProviderAdapter } from './normalized/adapter.js';
 import { FileChannelContextStore } from '../context/injection.js';
 import { ServerProjectionStrategyResolver } from '../context/projection-strategy.js';
 import { createProviderConnectionsSessionStore } from '../connections-state-store.js';
@@ -199,6 +203,22 @@ export function createProvider(config, debugLogger, options = {}) {
             return projectionStrategyResolver.resolve(input.channelId);
         },
     });
+    const outputMode = config.providerOutputMode ?? 'legacy';
+    if (outputMode === 'normalized') {
+        const provider = createHostedNativeProvider(config.provider, config.nativeProviderCommand, config);
+        return new NormalizedProviderAdapter({
+            ...(config.provider === 'codex' ? { sessionManagement: { root: config.sessionWorkspaceRoot,
+                    store: new FileCodexChannelSessionStore({ resolvePath: () => join(config.stateRootDir, 'independent-sessions', 'codex.json') }),
+                    loadProtectedNativeIds: () => readProtectedCodexSessions(config.stateRootDir),
+                    withOwnershipLock: createSessionOwnershipLock(join(config.stateRootDir, 'independent-sessions')),
+                } } : {}),
+            provider, prepare: (input) => turnPreparer.prepare(input),
+            ...(config.provider === 'codex' ? { prepareSession: (channelId) => turnPreparer.prepareSession(channelId, 'codex') } : {}),
+            resolveAgentId: () => config.resolveStableAgentId?.(), serverUrl: config.borgeeBaseUrl,
+            configureSession: (session) => configureHostedNativeSession(session, config.provider),
+            store: new FileCodexChannelSessionStore({ resolvePath: (agentId) => join(config.stateRootDir, 'native-sessions', config.provider, encodeURIComponent(agentId) + '.json') }),
+        });
+    }
     switch (config.provider) {
         case 'claude': {
             return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs);

package/dist/providers/normalized/adapter.d.ts

@@ -0,0 +1,107 @@
+import { type SessionDirectoryRequest, type SessionDirectoryResult, type SessionObservationRequest, type SessionObservationResult, type ServerRequestContext } from '../../plugin-sdk.js';
+import { type SessionControlRequest } from '../../plugin-sdk.js';
+import type { AgentInteractionResponse, AgentProviderAdapter, AgentSession } from '../../native-providers.js';
+import type { PreparedPromptContext, PreparedProviderTurnInput, ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import { type ProviderAdapter, type ProviderSessionControlContext, type ProviderSessionControlResult } from '../provider-adapter.js';
+import { type HostSessionManagementOptions } from './session-management.js';
+interface SessionStore {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}
+export interface NormalizedProviderOptions {
+    provider: AgentProviderAdapter;
+    prepare(input: ProviderInput): Promise<PreparedProviderTurnInput>;
+    prepareSession?(channelId: string): Promise<PreparedPromptContext | undefined>;
+    resolveAgentId(): string | undefined;
+    serverUrl: string;
+    store: SessionStore;
+    configureSession(session: AgentSession): Promise<void>;
+    sessionManagement?: Omit<HostSessionManagementOptions, 'provider' | 'find' | 'register' | 'resolveAgentId' | 'serverUrl'>;
+}
+/** Owns Host binding and business replies; native event interpretation stays in providers. */
+export declare class NormalizedProviderAdapter implements ProviderAdapter {
+    private readonly options;
+    readonly outputMode: "normalized";
+    readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
+    private readonly bindings;
+    private readonly bindingRecords;
+    private readonly relationPasses;
+    private readonly deferredRelations;
+    private readonly busy;
+    private readonly stores;
+    private saving;
+    private defaultAdmission;
+    private disposed;
+    private readonly management?;
+    constructor(options: NormalizedProviderOptions);
+    private hasIndependentOwner;
+    private get supportsDefaultOpening();
+    get supportsSessionManagement(): boolean;
+    describeSessionManagement(): Promise<import('../../plugin-sdk.js').SessionManagementAvailability>;
+    manageSession(request: import('../../plugin-sdk.js').SessionManagementRequest, context: ServerRequestContext): Promise<unknown>;
+    private openDefaultSession;
+    private registerIndependentSession;
+    get sessionInputOperations(): readonly ('start_turn' | 'steer' | 'next_turn')[];
+    get supportsSessionInput(): boolean;
+    private sessionPublication?;
+    setSessionPublication(publication: Parameters<NonNullable<ProviderAdapter['setSessionPublication']>>[0]): void;
+    publishSessionBindings(): void;
+    private publishAvailability;
+    private setAvailability;
+    private visibleRuntime;
+    private publishBinding;
+    private publishActivity;
+    private publisher;
+    private publishPreTurnError;
+    private publishTimeline;
+    listSessions(request: SessionDirectoryRequest, context: ServerRequestContext): SessionDirectoryResult;
+    describeSession(request: import('../../plugin-sdk.js').SessionDescriptionRequest, context: ServerRequestContext): import('../../plugin-sdk.js').SessionControlTarget | undefined;
+    observeSession(request: SessionObservationRequest, context: ServerRequestContext): Promise<SessionObservationResult>;
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    private bindingCurrent;
+    private controlBinding;
+    controlSession(request: SessionControlRequest, context: ProviderSessionControlContext): Promise<ProviderSessionControlResult>;
+    private registerInput;
+    private confirmInput;
+    private releaseExecution;
+    private reconcileAssociationMetadata;
+    private applyAssociation;
+    private observeOwned;
+    private processOwnedObservation;
+    private sendInput;
+    private finishLocalCommand;
+    private persistConfirmedBinding;
+    private withDefaultAdmission;
+    private bindingFor;
+    private bindingForDefault;
+    private admitChildren;
+    private adoptKnownChildren;
+    private observeSessionState;
+    private selectBinding;
+    private observe;
+    private queueObservation;
+    private drainObservations;
+    private processObservation;
+    private bindingCapabilities;
+    private retireInteractions;
+    private observeNativeTurn;
+    private restoreSession;
+    private observeEvent;
+    respondInteraction(input: {
+        channelId: string;
+        taskId?: string;
+        agentId: string;
+        requestId: string;
+        response: AgentInteractionResponse;
+        binding?: Pick<SessionControlRequest, 'binding_id' | 'native_session_id' | 'connection_generation'>;
+    }, context?: import('../../plugin-sdk.js').ServerRequestContext): Promise<AgentInteractionResponse>;
+    /** Capture and publication share the observation loop's synchronous ordering. */
+    syncNormalizedActivity(channelId: string, bindingId?: string): boolean;
+    cancelTurn(channelId: string, target?: Pick<SessionControlRequest, 'binding_id' | 'native_session_id' | 'connection_generation'>, context?: import('../../plugin-sdk.js').ServerRequestContext): Promise<boolean>;
+    interruptTurn(channelId: string): Promise<boolean>;
+    cancelSession(channelId: string): Promise<boolean>;
+    private closeBinding;
+    private disposeBinding;
+    dispose(): Promise<void>;
+}
+export {};