@volter/twin-togetherai 0.1.0

package/dist/src/togetherai-twin.d.ts

@@ -0,0 +1,83 @@
+import { type TogetheraiScenarioEngine } from './togetherai-scenario.js';
+import type { TogetheraiChatCompletion, TogetheraiMessageParam, SseSink } from './togetherai-types.js';
+/** The ONE base path Together's inference API serves. Everything the twin routes hangs off this. */
+export declare const TOGETHERAI_API_PREFIX = "/v1";
+export type TogetheraiRequest = {
+    /** The scenario engine (kernel grammar + this pack's vocabulary) — scripts chat turns. */
+    scenarioEngine?: TogetheraiScenarioEngine;
+    method: string;
+    path: string;
+    body?: string;
+    occurredAt?: string;
+    root?: string;
+    readOnly?: boolean;
+    /** The credential the caller presents (the SDK's bearer `Authorization` header). When a request
+     *  carries an auth SURFACE (this field set, or `headers` present), the twin holds it to the real
+     *  vendor rule: a credential is required → 401 on missing/invalid. In-process trusted calls
+     *  (capability verify, connector) omit BOTH and are not auth-gated. */
+    apiKey?: string;
+    /** Lower-cased request headers the HTTP server passes through so the handler can model auth
+     *  (401) and the deterministic fault triggers (429 / 402 / 503). */
+    headers?: Record<string, string>;
+    /** When set on a streaming POST, chunks are written here (no sockets). */
+    sseSink?: SseSink;
+};
+/** The handler response. `headers` (when present) are response headers the HTTP server should set
+ *  — e.g. `x-ratelimit-reset` on a modeled 429, or the redirect pair on the SDK's upload flow. */
+export type TogetheraiResponseEnvelope = {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+};
+type ToolChoice = 'auto' | 'none' | 'required' | {
+    name: string;
+};
+type ResponseFormat = {
+    kind: 'text';
+} | {
+    kind: 'json_object';
+} | {
+    kind: 'json_schema';
+    schema: unknown;
+};
+/** Together's `ChatCompletionRequest.context_length_exceeded_behavior` — a CLOSED documented
+ *  enum with default `error`. */
+declare const CONTEXT_LENGTH_BEHAVIORS: readonly ["truncate", "error"];
+type ContextLengthBehavior = (typeof CONTEXT_LENGTH_BEHAVIORS)[number];
+/** Together's `reasoning_effort` — a CLOSED documented enum. */
+declare const REASONING_EFFORTS: readonly ["low", "medium", "high"];
+type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+type ChatArgs = {
+    model: string;
+    messages: TogetheraiMessageParam[];
+    tools?: unknown;
+    n: number;
+    maxTokens?: number;
+    stop?: string[];
+    stream: boolean;
+    toolChoice?: ToolChoice;
+    parallelToolCalls: boolean;
+    legacyFunctions: boolean;
+    responseFormat: ResponseFormat;
+    seed?: number;
+    echo: boolean;
+    logprobs?: number;
+    reasoningEffort?: ReasoningEffort;
+    contextBehavior: ContextLengthBehavior;
+};
+export declare function buildChatCompletion(args: ChatArgs, occurredAt?: string, scenarioEngine?: TogetheraiScenarioEngine): TogetheraiChatCompletion | TogetheraiResponseEnvelope;
+/**
+ * Emit the vendor-faithful Together streaming sequence into the injected sink (NO sockets, NO
+ * setTimeout). Together's order: a first chunk with `delta:{role:'assistant'}`, then
+ * `delta:{content}` chunks (or tool_calls deltas), then a chunk carrying `finish_reason`. Every
+ * chunk carries Together's nullable `usage` + `warnings` (the schema declares both on
+ * ChatCompletionChunk itself — OpenAI puts usage only in an opt-in tail chunk). Ends with
+ * `data: [DONE]`. Deterministic + synchronous.
+ */
+export declare function streamChat(args: ChatArgs, sink: SseSink, occurredAt?: string, scenarioEngine?: TogetheraiScenarioEngine): TogetheraiChatCompletion | TogetheraiResponseEnvelope;
+export declare function handleTogetheraiTwinRequest(req: TogetheraiRequest): Promise<TogetheraiResponseEnvelope>;
+/** The twin-only door the SDK redirect flow uploads bytes through (kept OUT of the manifest:
+ *  twin-only scaffolding, not vendor surface — the same rule the `/twin` doors follow). */
+export declare const TOGETHERAI_UPLOAD_DOOR = "/twin/upload";
+export declare function handleTogetheraiUploadDoor(req: TogetheraiRequest): Promise<TogetheraiResponseEnvelope>;
+export {};