Types

All types exported from @arlopass/web-sdk.

import type {
  ChatMessage,
  ChatRole,
  ClientState,
  ContextWindowInfo,
  ChatInput,
  ChatOperationOptions,
  ChatStreamEvent,
  ChatSendResult,
  ConnectOptions,
  ConnectResult,
  ProviderDescriptor,
  SelectProviderInput,
  SelectProviderResult,
  ListProvidersResult,
  SessionId,
  RequestId,
  CorrelationId,
  TransportRequest,
  TransportResponse,
  TransportStream,
} from "@arlopass/web-sdk";

---

Core types

ChatRole

type ChatRole = "system" | "user" | "assistant";

ChatMessage

type ChatMessage = Readonly<{
  role: ChatRole;
  content: string;
}>;

ClientState

type ClientState =
  | "disconnected"
  | "connecting"
  | "connected"
  | "degraded"
  | "reconnecting"
  | "failed";

ChatInput

type ChatInput = Readonly<{
  messages: readonly ChatMessage[];
}>;

ChatOperationOptions

type ChatOperationOptions = Readonly<{
  timeoutMs?: number;
  signal?: AbortSignal;
}>;

ChatStreamEvent

type ChatStreamEvent =
  | Readonly<{
      type: "chunk";
      delta: string;
      index: number;
      correlationId: string;
    }>
  | Readonly<{ type: "done"; correlationId: string }>;

ChatSendResult

type ChatSendResult = Readonly<{
  message: ChatMessage;
  correlationId: string;
}>;

ContextWindowInfo

type ContextWindowInfo = Readonly<{
  maxTokens: number; // Context window size for the model
  usedTokens: number; // Estimated tokens in the context window
  reservedOutputTokens: number; // Tokens reserved for model response
  remainingTokens: number; // Tokens still available for input
  usageRatio: number; // 0–1 fraction of input budget used
}>;

Returned by ArlopassClient.getContextInfo() and ConversationManager.getContextInfo(). Use usageRatio for progress bars and remainingTokens for “context full” warnings.

ID types

type RequestId = string;
type CorrelationId = string;
type SessionId = string;

---

Connection types

ConnectOptions

type ConnectOptions = Readonly<{
  appId?: string;
  appSuffix?: string;
  appName?: string;
  appDescription?: string;
  appIcon?: string;
  origin?: string;
  timeoutMs?: number;
}>;

ConnectResult

type ConnectResult = Readonly<{
  sessionId: string;
  capabilities: readonly ProtocolCapability[];
  protocolVersion: string;
  correlationId: string;
}>;

---

Provider types

ProviderDescriptor

type ProviderDescriptor = Readonly<{
  providerId: string;
  providerName: string;
  models: readonly string[];
}>;

SelectProviderInput

type SelectProviderInput = Readonly<{
  providerId: string;
  modelId: string;
}>;

SelectProviderResult

type SelectProviderResult = Readonly<{
  providerId: string;
  modelId: string;
  correlationId: string;
}>;

ListProvidersResult

type ListProvidersResult = Readonly<{
  providers: readonly ProviderDescriptor[];
  correlationId: string;
}>;

---

Transport types

import type { ArlopassTransport } from "@arlopass/web-sdk";

ArlopassTransport

interface ArlopassTransport {
  request<TReq, TRes>(
    request: TransportRequest<TReq>,
  ): Promise<TransportResponse<TRes>>;
  stream<TReq, TRes>(
    request: TransportRequest<TReq>,
  ): Promise<TransportStream<TRes>>;
  disconnect?(sessionId: string): Promise<void>;
}

TransportRequest

type TransportRequest<TPayload = unknown> = Readonly<{
  envelope: ProtocolEnvelopePayload<TPayload>;
  timeoutMs?: number;
  signal?: AbortSignal;
}>;

TransportResponse

type TransportResponse<TPayload = unknown> = Readonly<{
  envelope: ProtocolEnvelopePayload<TPayload>;
}>;

TransportStream

type TransportStream<TPayload = unknown> = AsyncIterable<
  TransportResponse<TPayload>
>;

---

Payload types

ConnectPayload

type ConnectPayload = Readonly<{
  appId: string;
  requestedCapabilities: readonly ProtocolCapability[];
  appName?: string;
  appDescription?: string;
  appIcon?: string;
}>;

ChatSendPayload

type ChatSendPayload = Readonly<{
  messages: readonly ChatMessage[];
}>;

ChatSendResponsePayload

type ChatSendResponsePayload = Readonly<{
  message: ChatMessage;
}>;

ChatStreamPayload

type ChatStreamPayload = ChatSendPayload;

ChatStreamChunkPayload / ChatStreamDonePayload

type ChatStreamChunkPayload = Readonly<{
  type: "chunk";
  delta: string;
  index: number;
}>;

type ChatStreamDonePayload = Readonly<{ type: "done" }>;

---

Tool types

import type {
  ToolDefinition,
  ToolParameterSchema,
  ToolCall,
  ToolResult,
  ToolCallEvent,
  ToolResultEvent,
  ToolPrimingStartEvent,
  ToolPrimingMatchEvent,
  ToolPrimingEndEvent,
  ConversationStreamEvent,
} from "@arlopass/web-sdk";

ToolParameterSchema

type ToolParameterSchema = Readonly<{
  type: "object";
  properties?: Readonly<
    Record<
      string,
      Readonly<{
        type: string;
        description?: string;
        enum?: readonly string[];
      }>
    >
  >;
  required?: readonly string[];
}>;

ToolDefinition

type ToolDefinition = Readonly<{
  name: string;
  description: string;
  parameters?: ToolParameterSchema;
  handler?: (args: Record<string, unknown>) => Promise<string> | string;
}>;

ToolCall

type ToolCall = Readonly<{
  id: string;
  name: string;
  arguments: Record<string, unknown>;
  matchRange: Readonly<{ start: number; end: number }>;
}>;

ToolResult

type ToolResult = Readonly<{
  toolCallId: string;
  name: string;
  result: string;
}>;

ToolCallEvent

type ToolCallEvent = Readonly<{
  type: "tool_call";
  toolCallId: string;
  name: string;
  arguments: Record<string, unknown>;
  matchRange: Readonly<{ start: number; end: number }>;
}>;

ToolResultEvent

type ToolResultEvent = Readonly<{
  type: "tool_result";
  toolCallId: string;
  name: string;
  result: string;
}>;

ToolPrimingStartEvent

type ToolPrimingStartEvent = Readonly<{
  type: "tool_priming_start";
  message: string;
}>;

ToolPrimingMatchEvent

type ToolPrimingMatchEvent = Readonly<{
  type: "tool_priming_match";
  tools: readonly string[];
}>;

ToolPrimingEndEvent

type ToolPrimingEndEvent = Readonly<{ type: "tool_priming_end" }>;

ConversationStreamEvent

type ConversationStreamEvent =
  | ChatStreamEvent
  | ToolCallEvent
  | ToolResultEvent
  | ToolPrimingStartEvent
  | ToolPrimingMatchEvent
  | ToolPrimingEndEvent;