@valon-technologies/gestalt 0.0.1-alpha.18 → 0.0.1-alpha.20

package/src/agent-manager.ts

@@ -1,4 +1,3 @@
-import type { MessageInitShape } from "@bufbuild/protobuf";
 import {
   createClient,
   type Client,
@@ -7,24 +6,41 @@ import {
 import { createGrpcTransport } from "@connectrpc/connect-node";
 
 import {
-  AgentManagerCancelTurnRequestSchema,
-  AgentManagerCreateSessionRequestSchema,
-  AgentManagerCreateTurnRequestSchema,
-  AgentManagerGetSessionRequestSchema,
-  AgentManagerGetTurnRequestSchema,
   AgentManagerHost as AgentManagerHostService,
-  AgentManagerListInteractionsRequestSchema,
-  AgentManagerListSessionsRequestSchema,
-  AgentManagerListTurnEventsRequestSchema,
-  AgentManagerListTurnsRequestSchema,
-  AgentManagerResolveInteractionRequestSchema,
-  AgentManagerUpdateSessionRequestSchema,
+  type AgentInteraction as ProtoAgentInteraction,
+  type AgentSession as ProtoAgentSession,
+  type AgentTurn as ProtoAgentTurn,
+  type AgentTurnEvent as ProtoAgentTurnEvent,
+} from "./internal/gen/v1/agent_pb.ts";
+import type { Request } from "./api.ts";
+import {
+  agentActorFromProto,
+  agentMessageFromProto,
+  agentMessageToProto,
+  agentToolRefToProto,
+  agentTurnDisplayFromProto,
+} from "./agent-conversions.ts";
+import {
+  AgentExecutionStatus,
+  AgentInteractionState,
+  AgentInteractionType,
+  AgentSessionState,
+  AgentToolSourceMode,
   type AgentInteraction,
+  type AgentMessage,
   type AgentSession,
+  type AgentToolRef,
   type AgentTurn,
   type AgentTurnEvent,
-} from "./internal/gen/v1/agent_pb.ts";
-import type { Request } from "./api.ts";
+} from "./agent.ts";
+import {
+  dateFromTimestamp,
+  type JsonObjectInput,
+} from "./protocol.ts";
+import {
+  optionalObjectFromStruct,
+  optionalStruct,
+} from "./protocol-internal.ts";
 
 /** Environment variable containing the agent-manager host-service target. */
 export const ENV_AGENT_MANAGER_SOCKET = "GESTALT_AGENT_MANAGER_SOCKET";
@@ -33,50 +49,98 @@ export const ENV_AGENT_MANAGER_SOCKET_TOKEN =
   `${ENV_AGENT_MANAGER_SOCKET}_TOKEN`;
 const AGENT_MANAGER_RELAY_TOKEN_HEADER = "x-gestalt-host-service-relay-token";
 
+export interface AgentManagerWorkspaceGitCheckout {
+  url?: string | undefined;
+  ref?: string | undefined;
+  path?: string | undefined;
+}
+
+export interface AgentManagerWorkspace {
+  checkouts?: readonly AgentManagerWorkspaceGitCheckout[] | undefined;
+  cwd?: string | undefined;
+}
+
 /** Shape accepted when creating an agent session through the host manager. */
-export type AgentManagerCreateSessionInput = MessageInitShape<
-  typeof AgentManagerCreateSessionRequestSchema
->;
+export interface AgentManagerCreateSessionInput {
+  providerName: string;
+  model?: string | undefined;
+  clientRef?: string | undefined;
+  metadata?: JsonObjectInput | undefined;
+  idempotencyKey?: string | undefined;
+  workspace?: AgentManagerWorkspace | undefined;
+}
+
 /** Shape accepted when fetching an agent session through the host manager. */
-export type AgentManagerGetSessionInput = MessageInitShape<
-  typeof AgentManagerGetSessionRequestSchema
->;
+export interface AgentManagerGetSessionInput {
+  sessionId: string;
+}
+
 /** Shape accepted when listing agent sessions through the host manager. */
-export type AgentManagerListSessionsInput = MessageInitShape<
-  typeof AgentManagerListSessionsRequestSchema
->;
+export interface AgentManagerListSessionsInput {
+  providerName?: string | undefined;
+  state?: AgentSessionState | undefined;
+  limit?: number | undefined;
+  summaryOnly?: boolean | undefined;
+}
+
 /** Shape accepted when updating an agent session through the host manager. */
-export type AgentManagerUpdateSessionInput = MessageInitShape<
-  typeof AgentManagerUpdateSessionRequestSchema
->;
+export interface AgentManagerUpdateSessionInput {
+  sessionId: string;
+  clientRef?: string | undefined;
+  state?: AgentSessionState | undefined;
+  metadata?: JsonObjectInput | undefined;
+}
+
 /** Shape accepted when creating an agent turn through the host manager. */
-export type AgentManagerCreateTurnInput = MessageInitShape<
-  typeof AgentManagerCreateTurnRequestSchema
->;
+export interface AgentManagerCreateTurnInput {
+  sessionId: string;
+  model?: string | undefined;
+  messages?: readonly AgentMessage[] | undefined;
+  toolRefs?: readonly AgentToolRef[] | undefined;
+  toolSource?: AgentToolSourceMode | undefined;
+  responseSchema?: JsonObjectInput | undefined;
+  metadata?: JsonObjectInput | undefined;
+  idempotencyKey?: string | undefined;
+  modelOptions?: JsonObjectInput | undefined;
+}
+
 /** Shape accepted when fetching an agent turn through the host manager. */
-export type AgentManagerGetTurnInput = MessageInitShape<
-  typeof AgentManagerGetTurnRequestSchema
->;
+export interface AgentManagerGetTurnInput {
+  turnId: string;
+}
+
 /** Shape accepted when listing agent turns through the host manager. */
-export type AgentManagerListTurnsInput = MessageInitShape<
-  typeof AgentManagerListTurnsRequestSchema
->;
+export interface AgentManagerListTurnsInput {
+  sessionId: string;
+  status?: AgentExecutionStatus | undefined;
+  limit?: number | undefined;
+  summaryOnly?: boolean | undefined;
+}
+
 /** Shape accepted when cancelling an agent turn through the host manager. */
-export type AgentManagerCancelTurnInput = MessageInitShape<
-  typeof AgentManagerCancelTurnRequestSchema
->;
+export interface AgentManagerCancelTurnInput {
+  turnId: string;
+  reason?: string | undefined;
+}
+
 /** Shape accepted when listing events for an agent turn. */
-export type AgentManagerListTurnEventsInput = MessageInitShape<
-  typeof AgentManagerListTurnEventsRequestSchema
->;
+export interface AgentManagerListTurnEventsInput {
+  turnId: string;
+  afterSeq?: bigint | number | undefined;
+  limit?: number | undefined;
+}
+
 /** Shape accepted when listing agent interactions. */
-export type AgentManagerListInteractionsInput = MessageInitShape<
-  typeof AgentManagerListInteractionsRequestSchema
->;
+export interface AgentManagerListInteractionsInput {
+  turnId: string;
+}
+
 /** Shape accepted when resolving an agent interaction. */
-export type AgentManagerResolveInteractionInput = MessageInitShape<
-  typeof AgentManagerResolveInteractionRequestSchema
->;
+export interface AgentManagerResolveInteractionInput {
+  turnId: string;
+  interactionId: string;
+  resolution?: JsonObjectInput | undefined;
+}
 
 /**
  * Client for managing agent sessions, turns, events, and interactions.
@@ -113,18 +177,27 @@ export class AgentManager {
   async createSession(
     request: AgentManagerCreateSessionInput,
   ): Promise<AgentSession> {
-    return await this.client.createSession({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentSessionFromProto(
+      await this.client.createSession({
+        providerName: request.providerName,
+        model: request.model ?? "",
+        clientRef: request.clientRef ?? "",
+        metadata: optionalStruct(request.metadata),
+        idempotencyKey: request.idempotencyKey ?? "",
+        invocationToken: this.invocationToken,
+        workspace: workspaceToProto(request.workspace),
+      }),
+    );
   }
 
   /** Fetches one agent session. */
   async getSession(request: AgentManagerGetSessionInput): Promise<AgentSession> {
-    return await this.client.getSession({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentSessionFromProto(
+      await this.client.getSession({
+        sessionId: request.sessionId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Lists agent sessions visible to the invocation token. */
@@ -132,53 +205,79 @@ export class AgentManager {
     request: AgentManagerListSessionsInput = {},
   ): Promise<AgentSession[]> {
     const response = await this.client.listSessions({
-      ...request,
+      providerName: request.providerName ?? "",
       invocationToken: this.invocationToken,
+      state: request.state ?? AgentSessionState.UNSPECIFIED,
+      limit: request.limit ?? 0,
+      summaryOnly: request.summaryOnly ?? false,
     });
-    return [...response.sessions];
+    return response.sessions.map(agentSessionFromProto);
   }
 
   /** Updates mutable fields on an agent session. */
   async updateSession(
     request: AgentManagerUpdateSessionInput,
   ): Promise<AgentSession> {
-    return await this.client.updateSession({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentSessionFromProto(
+      await this.client.updateSession({
+        sessionId: request.sessionId,
+        clientRef: request.clientRef ?? "",
+        state: request.state ?? AgentSessionState.UNSPECIFIED,
+        metadata: optionalStruct(request.metadata),
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Creates an agent turn. */
   async createTurn(request: AgentManagerCreateTurnInput): Promise<AgentTurn> {
-    return await this.client.createTurn({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentTurnFromProto(
+      await this.client.createTurn({
+        sessionId: request.sessionId,
+        model: request.model ?? "",
+        messages: request.messages?.map(agentMessageToProto) ?? [],
+        toolRefs: request.toolRefs?.map(agentToolRefToProto) ?? [],
+        toolSource: request.toolSource ?? AgentToolSourceMode.UNSPECIFIED,
+        responseSchema: optionalStruct(request.responseSchema),
+        metadata: optionalStruct(request.metadata),
+        idempotencyKey: request.idempotencyKey ?? "",
+        invocationToken: this.invocationToken,
+        modelOptions: optionalStruct(request.modelOptions),
+      }),
+    );
   }
 
   /** Fetches one agent turn. */
   async getTurn(request: AgentManagerGetTurnInput): Promise<AgentTurn> {
-    return await this.client.getTurn({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentTurnFromProto(
+      await this.client.getTurn({
+        turnId: request.turnId,
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Lists turns for an agent session. */
   async listTurns(request: AgentManagerListTurnsInput): Promise<AgentTurn[]> {
     const response = await this.client.listTurns({
-      ...request,
+      sessionId: request.sessionId,
       invocationToken: this.invocationToken,
+      status: request.status ?? AgentExecutionStatus.UNSPECIFIED,
+      limit: request.limit ?? 0,
+      summaryOnly: request.summaryOnly ?? false,
     });
-    return [...response.turns];
+    return response.turns.map(agentTurnFromProto);
   }
 
   /** Cancels an in-progress agent turn. */
   async cancelTurn(request: AgentManagerCancelTurnInput): Promise<AgentTurn> {
-    return await this.client.cancelTurn({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentTurnFromProto(
+      await this.client.cancelTurn({
+        turnId: request.turnId,
+        reason: request.reason ?? "",
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 
   /** Lists events emitted for an agent turn. */
@@ -186,10 +285,12 @@ export class AgentManager {
     request: AgentManagerListTurnEventsInput,
   ): Promise<AgentTurnEvent[]> {
     const response = await this.client.listTurnEvents({
-      ...request,
+      turnId: request.turnId,
+      afterSeq: BigInt(request.afterSeq ?? 0),
+      limit: request.limit ?? 0,
       invocationToken: this.invocationToken,
     });
-    return [...response.events];
+    return response.events.map(agentTurnEventFromProto);
   }
 
   /** Lists pending or completed agent interactions. */
@@ -197,20 +298,24 @@ export class AgentManager {
     request: AgentManagerListInteractionsInput,
   ): Promise<AgentInteraction[]> {
     const response = await this.client.listInteractions({
-      ...request,
+      turnId: request.turnId,
       invocationToken: this.invocationToken,
     });
-    return [...response.interactions];
+    return response.interactions.map(agentInteractionFromProto);
   }
 
   /** Resolves an agent interaction with a host response. */
   async resolveInteraction(
     request: AgentManagerResolveInteractionInput,
   ): Promise<AgentInteraction> {
-    return await this.client.resolveInteraction({
-      ...request,
-      invocationToken: this.invocationToken,
-    });
+    return agentInteractionFromProto(
+      await this.client.resolveInteraction({
+        turnId: request.turnId,
+        interactionId: request.interactionId,
+        resolution: optionalStruct(request.resolution),
+        invocationToken: this.invocationToken,
+      }),
+    );
   }
 }
 
@@ -226,6 +331,90 @@ function normalizeInvocationToken(requestOrToken: Request | string): string {
   return trimmed;
 }
 
+function workspaceToProto(workspace?: AgentManagerWorkspace | undefined) {
+  if (workspace === undefined) {
+    return undefined;
+  }
+  return {
+    checkouts: workspace.checkouts?.map((checkout) => ({
+      url: checkout.url ?? "",
+      ref: checkout.ref ?? "",
+      path: checkout.path ?? "",
+    })) ?? [],
+    cwd: workspace.cwd ?? "",
+  };
+}
+
+function agentSessionFromProto(session: ProtoAgentSession): AgentSession {
+  return {
+    id: session.id,
+    providerName: session.providerName,
+    model: session.model,
+    clientRef: session.clientRef,
+    state: session.state as AgentSessionState,
+    metadata: optionalObjectFromStruct(session.metadata),
+    createdBy: agentActorFromProto(session.createdBy),
+    createdAt: optionalDate(session.createdAt),
+    updatedAt: optionalDate(session.updatedAt),
+    lastTurnAt: optionalDate(session.lastTurnAt),
+  };
+}
+
+function agentTurnFromProto(turn: ProtoAgentTurn): AgentTurn {
+  return {
+    id: turn.id,
+    sessionId: turn.sessionId,
+    providerName: turn.providerName,
+    model: turn.model,
+    status: turn.status as AgentExecutionStatus,
+    messages: turn.messages.map(agentMessageFromProto),
+    outputText: turn.outputText,
+    structuredOutput: optionalObjectFromStruct(turn.structuredOutput),
+    statusMessage: turn.statusMessage,
+    createdBy: agentActorFromProto(turn.createdBy),
+    createdAt: optionalDate(turn.createdAt),
+    startedAt: optionalDate(turn.startedAt),
+    completedAt: optionalDate(turn.completedAt),
+    executionRef: turn.executionRef,
+  };
+}
+
+function agentTurnEventFromProto(event: ProtoAgentTurnEvent): AgentTurnEvent {
+  return {
+    id: event.id,
+    turnId: event.turnId,
+    seq: event.seq,
+    type: event.type,
+    source: event.source,
+    visibility: event.visibility,
+    data: optionalObjectFromStruct(event.data),
+    createdAt: optionalDate(event.createdAt),
+    display: agentTurnDisplayFromProto(event.display),
+  };
+}
+
+function agentInteractionFromProto(
+  interaction: ProtoAgentInteraction,
+): AgentInteraction {
+  return {
+    id: interaction.id,
+    type: interaction.type as AgentInteractionType,
+    state: interaction.state as AgentInteractionState,
+    title: interaction.title,
+    prompt: interaction.prompt,
+    request: optionalObjectFromStruct(interaction.request),
+    resolution: optionalObjectFromStruct(interaction.resolution),
+    createdAt: optionalDate(interaction.createdAt),
+    resolvedAt: optionalDate(interaction.resolvedAt),
+    turnId: interaction.turnId,
+    sessionId: interaction.sessionId,
+  };
+}
+
+function optionalDate(timestamp?: Parameters<typeof dateFromTimestamp>[0]) {
+  return timestamp === undefined ? undefined : dateFromTimestamp(timestamp);
+}
+
 function agentManagerTransportOptions(rawTarget: string): {
   baseUrl: string;
   nodeOptions?: { path: string };