@kaoruisaac/pedelec 0.1.0 → 0.1.3

package/dist/index.d.ts

@@ -1,18 +1,92 @@
 export type PedelecOptions = {
     bridgeTimeoutMs?: number;
 };
-export type ProviderCode = "codex" | "gemini" | "opencode" | "cursor" | "claude";
-type CreateSessionInputWithProvider = {
+export type ProviderCode = "codex" | "gemini" | "opencode" | "cursor" | "claude" | "ollama";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type ToolArgsSchemaMeta<TDefault extends JsonValue = JsonValue> = {
+    description?: string;
+    default?: TDefault;
+    examples?: TDefault[];
+};
+export type ToolArgsStringSchema = ToolArgsSchemaMeta<string> & {
+    type: "string";
+    enum?: string[];
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+};
+export type ToolArgsNumberSchema = ToolArgsSchemaMeta<number> & {
+    type: "number";
+    enum?: number[];
+    minimum?: number;
+    maximum?: number;
+};
+export type ToolArgsIntegerSchema = ToolArgsSchemaMeta<number> & {
+    type: "integer";
+    enum?: number[];
+    minimum?: number;
+    maximum?: number;
+};
+export type ToolArgsBooleanSchema = ToolArgsSchemaMeta<boolean> & {
+    type: "boolean";
+    enum?: boolean[];
+};
+export type ToolArgsArraySchema = ToolArgsSchemaMeta<JsonValue[]> & {
+    type: "array";
+    items: ToolArgsSchemaNode;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+};
+export type ToolArgsObjectSchema = ToolArgsSchemaMeta<Record<string, JsonValue>> & {
+    type: "object";
+    properties?: Record<string, ToolArgsSchemaNode>;
+    required?: string[];
+};
+export type ToolArgsOneOfSchema = ToolArgsSchemaMeta & {
+    oneOf: ToolArgsSchemaNode[];
+};
+export type ToolArgsSchemaNode = ToolArgsStringSchema | ToolArgsNumberSchema | ToolArgsIntegerSchema | ToolArgsBooleanSchema | ToolArgsArraySchema | ToolArgsObjectSchema | ToolArgsOneOfSchema;
+export type ToolArgsSchema = ToolArgsObjectSchema;
+export type ToolSpecificHandler<TArgs = unknown, TResult = unknown> = (args: TArgs, ctx: ToolCallContext) => TResult | Promise<TResult>;
+export type ToolDefinition<TArgs = unknown, TResult = unknown, TName extends string = string> = {
+    name: TName;
+    description: string;
+    argsSchema: ToolArgsSchema;
+    timeoutMs?: number;
+    handler?: ToolSpecificHandler<TArgs, TResult>;
+};
+export type SkillsInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
+    guidance: string;
+    tools: TTools;
+};
+export type ToolNameOf<TTools extends readonly ToolDefinition[]> = Extract<TTools[number]["name"], string>;
+export type SerializableToolManifest = {
+    name: string;
+    description: string;
+    argsSchema: ToolArgsSchema;
+    timeoutMs?: number;
+};
+export type SerializableSkillsManifest = {
+    guidance: string;
+    tools: SerializableToolManifest[];
+};
+type CreateSessionInputWithProvider<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     provider: ProviderCode;
     model?: string;
-    skillsUrls?: string[];
+    skills?: SkillsInput<TTools>;
+    autoEndOnDisconnect?: boolean;
 };
-type CreateSessionInputWithDefaults = {
+type CreateSessionInputWithDefaults<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     provider?: undefined;
     model?: never;
-    skillsUrls?: string[];
+    skills?: SkillsInput<TTools>;
+    autoEndOnDisconnect?: boolean;
 };
-export type CreateSessionInput = CreateSessionInputWithProvider | CreateSessionInputWithDefaults;
+export type CreateSessionInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = CreateSessionInputWithProvider<TTools> | CreateSessionInputWithDefaults<TTools>;
 export type ProviderInfo = {
     name: string;
     code: ProviderCode;
@@ -22,7 +96,7 @@ export type ProviderInfo = {
 };
 export type PedelecSettings = {
     defaultProvider: ProviderCode | null;
-    defaultModel: string | null;
+    defaultModels: Partial<Record<ProviderCode, string>>;
 };
 export type ApprovalStatus = {
     installed: boolean;
@@ -35,6 +109,43 @@ export type PedelecError = {
     details?: unknown;
 };
 export type PedelecSessionStatus = "idle" | "running" | "waiting_tool_result" | "ended" | "error";
+export type PedelecEventContext = {
+    sessionId: string;
+    provider: string;
+    model?: string;
+    sessionCreatedAt: number;
+    eventReceivedAt?: number;
+    eventEmittedAt: number;
+    turnId?: string;
+    turnStartedAt?: number;
+    turnKind?: "user" | "prepare";
+    source: "core" | "sdk";
+};
+export type ChatEventContext = PedelecEventContext & {
+    type: "chat_delta";
+    turnId: string;
+    turnStartedAt: number;
+    eventReceivedAt: number;
+};
+export type ToolCallContext = PedelecEventContext & {
+    type: "tool_call";
+    toolRequestId: string;
+    tool: string;
+    turnId: string;
+    turnStartedAt: number;
+    eventReceivedAt: number;
+};
+export type StatusEventContext = PedelecEventContext & {
+    type: "status_changed" | "sdk_status_changed";
+    status: PedelecSessionStatus;
+    previousStatus: PedelecSessionStatus;
+};
+export type ErrorEventContext = PedelecEventContext & {
+    type: "error" | "sdk_error";
+};
+export type EndedEventContext = PedelecEventContext & {
+    type: "ended" | "sdk_ended";
+};
 type SessionEvent = {
     type: "chat_delta";
     channelId: string;
@@ -72,11 +183,16 @@ type SessionEvent = {
     sessionId: string;
     seq?: number;
 };
-type ChatHandler = (text: string) => void;
-type ToolHandler = (tool: string, args: unknown) => unknown | Promise<unknown>;
-type ErrorHandler = (error: PedelecError) => void;
-type StatusHandler = (status: PedelecSessionStatus) => void;
-type EndedHandler = () => void;
+type EventDispatchMeta = {
+    source: "core" | "sdk";
+    eventReceivedAt?: number;
+};
+type ChatHandler = (text: string, ctx: ChatEventContext) => void;
+type GenericToolHandler<TToolName extends string = string> = (tool: TToolName, args: unknown, ctx: ToolCallContext) => unknown | Promise<unknown>;
+type ErrorHandler = (error: PedelecError, ctx: ErrorEventContext) => void;
+type StatusHandler = (status: PedelecSessionStatus, ctx: StatusEventContext) => void;
+type EndedHandler = (ctx: EndedEventContext) => void;
+export declare function defineTool<TArgs = unknown, TResult = unknown, const TName extends string = string>(tool: ToolDefinition<TArgs, TResult, TName>): ToolDefinition<TArgs, TResult, TName>;
 export declare class Pedelec {
     private readonly pageWindow;
     private readonly channelId;
@@ -88,11 +204,12 @@ export declare class Pedelec {
     private disconnectedError;
     private port;
     constructor(options?: PedelecOptions);
-    createSession(input?: CreateSessionInput): Promise<PedelecSession>;
+    createSession(): Promise<PedelecSession<string>>;
+    createSession<const TTools extends readonly ToolDefinition[]>(input: CreateSessionInput<TTools>): Promise<PedelecSession<ToolNameOf<TTools>>>;
     listProviders(): Promise<ProviderInfo[]>;
     getSettings(): Promise<PedelecSettings>;
     getApprovalStatus(): Promise<ApprovalStatus>;
-    resumeSession(sessionId: string): Promise<PedelecSession>;
+    resumeSession(sessionId: string): Promise<PedelecSession<string>>;
     request<T>(type: string, payload?: Record<string, unknown>): Promise<T>;
     unregisterSession(sessionId: string): void;
     private resolveCreateSessionInput;
@@ -107,34 +224,57 @@ export declare class Pedelec {
     private handleDisconnect;
     private broadcastError;
 }
-export declare class PedelecSession {
+export declare class PedelecSession<TToolName extends string = string> {
     private readonly client;
     readonly sessionId: string;
     readonly provider: string;
     readonly model?: string;
+    readonly sessionCreatedAt: number;
     private status;
     private pendingSend;
-    private toolHandler;
+    private pendingPrepare;
+    private preparePromise;
+    private prepared;
+    private activeTurn;
+    private genericToolHandler;
+    private inlineToolHandlers;
+    private readonly namedToolHandlers;
     private readonly chatHandlers;
     private readonly errorHandlers;
     private readonly statusHandlers;
     private readonly endedHandlers;
-    constructor(client: Pedelec, sessionId: string, provider: string, model?: string);
+    constructor(client: Pedelec, sessionId: string, provider: string, model?: string, inlineToolHandlers?: Map<string, ToolSpecificHandler>);
+    prepare(): Promise<void>;
     sendText(text: string): Promise<void>;
     onChat(handler: ChatHandler): () => void;
-    onTool(handler: ToolHandler): () => void;
+    onTool(handler: GenericToolHandler<TToolName>): () => void;
+    onTool<TArgs = unknown, TResult = unknown>(toolName: TToolName, handler: ToolSpecificHandler<TArgs, TResult>): () => void;
     onError(handler: ErrorHandler): () => void;
     onStatus(handler: StatusHandler): () => void;
     onEnded(handler: EndedHandler): () => void;
     getStatus(): PedelecSessionStatus;
     end(): Promise<void>;
-    handleEvent(event: SessionEvent): void;
+    handleEvent(event: SessionEvent, meta?: EventDispatchMeta): void;
+    replaceInlineToolHandlers(handlers: Map<string, ToolSpecificHandler>): void;
     private handleToolCall;
     private resolvePendingSend;
+    private resolvePendingPrepare;
+    private resolveActivePending;
     private rejectPendingSend;
+    private rejectPendingPrepare;
+    private rejectActivePending;
     private clearPendingSend;
+    private clearPendingPrepare;
     private markEnded;
     private emitError;
     private setStatus;
+    private requireActiveTurn;
+    private finishActiveTurn;
+    private createBaseContext;
+    private createChatContext;
+    private createToolCallContext;
+    private createStatusContext;
+    private createErrorContext;
+    private createEndedContext;
 }
 export {};