@tarkahq/sdk 0.0.0-stage → 0.3.0

package/dist/esm/transport.js

@@ -0,0 +1,110 @@
+import { Client, Metadata, credentials, status, } from "@grpc/grpc-js";
+export function validateTimeout(timeoutMs) {
+    if (timeoutMs !== undefined &&
+        (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
+        throw new TypeError("timeoutMs must be a finite, non-negative number");
+    }
+}
+function prepareCall(options, defaultTimeoutMs) {
+    const { timeoutMs = defaultTimeoutMs, signal, metadata, ...grpcOptions } = options;
+    validateTimeout(timeoutMs);
+    if (timeoutMs !== undefined) {
+        const absolute = grpcOptions.deadline instanceof Date
+            ? grpcOptions.deadline.getTime()
+            : (grpcOptions.deadline ?? Infinity);
+        grpcOptions.deadline = Math.min(absolute, Date.now() + timeoutMs);
+    }
+    if (signal?.aborted)
+        throw cancelledError();
+    const headers = metadata instanceof Metadata ? metadata.clone() : new Metadata();
+    if (metadata && !(metadata instanceof Metadata)) {
+        for (const [key, value] of Object.entries(metadata)) {
+            for (const item of Array.isArray(value) ? value : [value])
+                headers.add(key, item);
+        }
+    }
+    return { signal, metadata: headers, grpcOptions };
+}
+function cancelledError() {
+    return Object.assign(new Error("Call cancelled"), {
+        code: status.CANCELLED,
+        details: "Call cancelled",
+        metadata: new Metadata(),
+    });
+}
+/**
+ * Wrap a generated service definition on a caller-owned channel.
+ * The caller remains responsible for closing the channel.
+ *
+ * @param definition - Generated service definition from a service-specific grpc export.
+ * @param channel - Channel whose authentication and lifecycle are managed by the caller.
+ * @param defaults - Optional default RPC timeout in milliseconds.
+ * @returns Native methods returning promises or lazy async iterables. Empty requests may be omitted; failures retain native gRPC errors.
+ */
+export function createServiceClient(definition, channel, defaults = {}) {
+    validateTimeout(defaults.timeoutMs);
+    const transport = new Client(channel.getTarget(), credentials.createInsecure(), {
+        channelOverride: channel,
+    });
+    const methods = {};
+    for (const [key, method] of Object.entries(definition.methods)) {
+        if (method.requestStream) {
+            throw new TypeError(`Client-streaming RPCs are not supported: ${definition.fullName}/${method.name}`);
+        }
+        const path = `/${definition.fullName}/${method.name}`;
+        const emptyRequest = Object.keys(method.requestType.fromPartial({})).length === 0;
+        const argumentsFor = (request, options) => emptyRequest
+            ? {
+                request: {},
+                options: options ?? request ?? {},
+            }
+            : { request, options: options ?? {} };
+        const serialize = (request) => Buffer.from(method.requestType
+            .encode(method.requestType.fromPartial(request))
+            .finish());
+        const deserialize = (bytes) => method.responseType.decode(bytes);
+        if (method.responseStream) {
+            methods[key] = async function* (input, callOptions) {
+                const { request, options } = argumentsFor(input, callOptions);
+                const { signal, metadata, grpcOptions } = prepareCall(options, defaults.timeoutMs);
+                const call = transport.makeServerStreamRequest(path, serialize, deserialize, request, metadata, grpcOptions);
+                const cancel = () => call.cancel();
+                signal?.addEventListener("abort", cancel, { once: true });
+                // Covers an abort from a synchronous gRPC interceptor during call setup.
+                if (signal?.aborted)
+                    cancel();
+                try {
+                    // Node's readable iterator preserves stream backpressure and gRPC errors.
+                    for await (const response of call)
+                        yield response;
+                }
+                finally {
+                    signal?.removeEventListener("abort", cancel);
+                    // A consumer breaking out of for-await must also stop server-side work.
+                    if (!call.readableEnded)
+                        call.cancel();
+                }
+            };
+        }
+        else {
+            methods[key] = async (input, callOptions) => {
+                const { request, options } = argumentsFor(input, callOptions);
+                const { signal, metadata, grpcOptions } = prepareCall(options, defaults.timeoutMs);
+                return new Promise((resolve, reject) => {
+                    const call = transport.makeUnaryRequest(path, serialize, deserialize, request, metadata, grpcOptions, (error, response) => {
+                        signal?.removeEventListener("abort", cancel);
+                        if (error)
+                            reject(error);
+                        else
+                            resolve(response);
+                    });
+                    const cancel = () => call.cancel();
+                    signal?.addEventListener("abort", cancel, { once: true });
+                    if (signal?.aborted)
+                        cancel();
+                });
+            };
+        }
+    }
+    return Object.freeze(methods);
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,309 @@
+import type * as i from "./generated/tarka/inference/v1/inference.js";
+import type * as p from "./generated/tarka/provisioning/v1/provisioning.js";
+import type * as s from "./generated/tarka/provisioning/v1/sandbox.js";
+/** A JSON-compatible value: null, primitive, array, or object. Buffers, Dates, bigint, and undefined are not JSON values. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+/** An ordinary JSON object used for OpenAI bodies and extension fields. Narrow dynamic result values before using them in TypeScript. */
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+/** Per-call metadata as a plain object. Values may be strings, Buffers, or arrays; Buffer keys must end in `-bin`. */
+export type Metadata = Readonly<Record<string, string | Buffer | readonly (string | Buffer)[]>>;
+/** Request settings accepted by resource methods. Calls with no input accept these directly; other methods take them after the input. */
+export interface RequestOptions {
+    /**
+     * Client timeout in milliseconds; overrides the client default. Zero expires immediately.
+     *
+     * Must be finite and non-negative. Ordinary RPCs have no SDK timeout if both defaults are omitted; streams use one timeout for their entire lifetime. Wait/run helpers use this as a total budget and default to 60,000 ms.
+     */
+    timeoutMs?: number;
+    /** AbortSignal for cancellation. Cancelling a wait stops polling but does not necessarily stop remote execution or undo a mutation. */
+    signal?: AbortSignal;
+    /** Additional per-call metadata. Use a `-bin` key for Buffer values; inputs are copied into the outgoing request. */
+    metadata?: Metadata;
+}
+/** Settings for sandbox readiness, execution waiting, and `run()`. The timeout is a total budget including requests and polling delays, defaulting to 60 seconds. */
+export interface WaitOptions extends RequestOptions {
+    /** Delay in milliseconds between incomplete polls. Defaults to 1,000; must be finite and greater than zero. */
+    pollIntervalMs?: number;
+}
+/** Convert generated message shapes into public data types, retaining Buffer, Date, and bigint while replacing opaque protobuf values with JsonValue. */
+export type Data<T> = 0 extends 1 & T ? JsonValue : T extends Date | Uint8Array ? T : T extends Array<infer V> ? Data<V>[] : T extends object ? {
+    [K in keyof T]: Data<T[K]>;
+} : T;
+/** Build a public request shape: selected keys are required, remaining fields are optional, and scoped/internal fields are omitted. */
+export type Input<T, Required extends keyof T = never, Omitted extends keyof T = never> = {
+    [K in Required]: Data<T[K]>;
+} & Partial<Omit<{
+    [K in keyof T]: Data<T[K]>;
+}, Required | Omitted>>;
+/** An inference-visible model record. Its `id` can be used in inference requests; 64-bit values such as `created` remain bigint. */
+export type Model = Data<i.Model>;
+/** A control plane model record with provisioning information. Use `modelAlias` for inference requests; catalog `id` is the registry identifier. */
+export type CatalogModel = Data<p.Model>;
+/** A full chat completion, including all choices, usage, and tool calls when provided by the model. */
+export type ChatCompletion = Data<i.ChatCompletion>;
+/** A full streaming chat chunk. Choices may contain text or tool-call deltas; some chunks carry only usage. */
+export type ChatChunk = Data<i.ChatCompletionChunk>;
+/** A named callable function, with optional description, JSON-schema parameters, and model-supported settings. */
+export interface FunctionInput extends Input<i.FunctionDefinition, "name"> {
+    /** Function name included in model-generated tool calls. */
+    name: string;
+    /** Explain what the function does and when the model should call it. */
+    description?: string;
+    /** JSON Schema describing the arguments accepted by the function. */
+    parameters?: JsonObject;
+    /** Request strict schema adherence when supported by the model. */
+    strict?: boolean;
+}
+/** A function tool with its definition, or a custom tool described by an ordinary JSON object. */
+export type ToolInput = {
+    type: "function";
+    function: FunctionInput;
+} | {
+    type: "custom";
+    custom: JsonObject;
+};
+/** A tool call included in a chat message. Function arguments are a JSON-encoded string, not a JavaScript object. */
+export type ToolCallInput = Input<i.ToolCall, "id" | "type", "function"> & {
+    function?: {
+        name: string;
+        arguments: string;
+    };
+};
+/** A conversation message with an explicit role and optional content, tool calls, or tool response linkage. */
+export type ChatMessage = Input<i.ChatMessage, never, "role" | "toolCalls"> & {
+    /** Role of this message in the conversation. */
+    role: "system" | "developer" | "user" | "assistant" | "tool" | "function";
+    /** Text or model-supported JSON content parts. Assistant tool-call messages may omit content. */
+    content?: JsonValue;
+    /** Optional participant name supplied to the model. */
+    name?: string;
+    /** Tool calls from an assistant message; function arguments are JSON strings. */
+    toolCalls?: ToolCallInput[];
+    /** For a tool response, the identifier of the assistant tool call being answered. */
+    toolCallId?: string;
+};
+/**
+ * Typed chat input: choose a prompt with optional system instruction, or a non-empty messages array.
+ *
+ * Provide a model identifier from inference discovery. Other generation settings are optional and model-dependent; the chosen SDK method sets streaming mode.
+ * @example
+ * const input = { model: "your-model-alias", prompt: "Hello", maxTokens: 100 };
+ */
+export type ChatInput = Input<i.ChatCompletionRequest, "model", "stream" | "messages" | "tools" | "functions"> & {
+    /** Inference model identifier or alias, available from `client.models.list()`. */
+    model: string;
+    /** Requested output token limit. Supported limits and interaction with maxCompletionTokens depend on the model. */
+    maxTokens?: number;
+    /** Completion token budget, including reasoning tokens for models that count them. Support depends on the model. */
+    maxCompletionTokens?: number;
+    /** Sampling temperature; lower values generally produce less varied text. Allowed values and defaults depend on the model. */
+    temperature?: number;
+    /** Nucleus sampling threshold. Support, allowed values, and defaults depend on the model. */
+    topP?: number;
+    /** Maximum number of candidate tokens considered at each sampling step, when supported. */
+    topK?: number;
+    /** Repetition penalty passed to models that support it. */
+    repeatPenalty?: number;
+    /** Penalty for reusing tokens already present in the response, when supported. */
+    presencePenalty?: number;
+    /** Penalty based on how often a token has appeared in the response, when supported. */
+    frequencyPenalty?: number;
+    /** Stop sequence or sequences in the model's supported JSON format, commonly a string or array of strings. */
+    stop?: JsonValue;
+    /** Sampling seed as a bigint, for example `42n`. Repeatability depends on the model and serving configuration. */
+    seed?: bigint;
+    /** Optional end-user identifier supplied to the inference service. */
+    user?: string;
+    /** Tools the model may call. Inspect `chat.create()` results for tool calls; the SDK does not execute them. */
+    tools?: ToolInput[];
+    /** Model-supported tool selection, such as `"auto"`, `"none"`, or a JSON object selecting a tool. */
+    toolChoice?: JsonValue;
+    /** Legacy function definitions. Prefer tools for models that support tool calls. */
+    functions?: FunctionInput[];
+    /** Legacy function selection in the model's supported JSON format. */
+    functionCall?: JsonValue;
+    /** Requested number of choices when supported. Text helpers select choice 0; use create/stream to inspect all choices. */
+    n?: number;
+    /** Model-supported output format, such as `{ type: "json_object" }` or a JSON Schema configuration. */
+    responseFormat?: JsonObject;
+    /** Request token log probabilities when supported by the model. */
+    logprobs?: boolean;
+    /** Number of alternative token log probabilities to request when supported. */
+    topLogprobs?: number;
+    /** Map of token IDs to model-supported sampling biases. */
+    logitBias?: Record<string, number>;
+    /** Allow the model to request multiple tool calls in a turn when supported. */
+    parallelToolCalls?: boolean;
+    /** Streaming response settings; usage-only chunks are available through `chat.stream()`. */
+    streamOptions?: {
+        /** Ask the server to include usage information in the stream. */
+        includeUsage?: boolean;
+        /** Request stream obfuscation fields when supported by the service. */
+        includeObfuscation?: boolean;
+    };
+    /** Requested output modalities supported by the model, for example `["text", "audio"]`. */
+    modalities?: string[];
+    /** Model-supported audio output settings, such as voice and format. */
+    audio?: JsonObject;
+    /** Model-supported predicted-output configuration. */
+    prediction?: JsonObject;
+    /** Reasoning effort setting accepted by the selected model. */
+    reasoningEffort?: string;
+    /** Service tier requested from the inference service, when supported. */
+    serviceTier?: string;
+    /** Request storage of the completion when the service supports it. */
+    store?: boolean;
+    /** Application metadata in the model request body. Transport headers belong in the second argument's `metadata` option. */
+    metadata?: JsonObject;
+    /** Additional model-specific JSON body fields not represented by the typed settings. */
+    extraBody?: JsonObject;
+} & ({
+    /** User text, converted to a user message. Choose this or messages. */
+    prompt: string;
+    /** Optional system instruction prepended before the prompt. */
+    system?: string;
+    messages?: never;
+} | {
+    /** Non-empty conversation history. Choose this or prompt/system. */
+    messages: ChatMessage[];
+    prompt?: never;
+    system?: never;
+});
+/** A JSON event from Responses or JSON chat streaming, without a protobuf envelope. */
+export interface ResponseEvent {
+    /** Server-provided event name used to distinguish event payloads. */
+    type: string;
+    /** Event payload as ordinary JSON. Its fields depend on the event type. */
+    data: JsonObject;
+}
+/** OCR model and exactly one of `image` or a non-empty `images` array, using model-supported image representations. The SDK chooses streaming mode. */
+export type OcrInput = Input<i.OCRRequest, "model", "stream" | "image" | "images"> & ({
+    image: string;
+    images?: never;
+} | {
+    images: string[];
+    image?: never;
+});
+/** Full OCR output, including recognized text and any additional model-provided fields. */
+export type OcrResult = Data<i.OCRResponse>;
+/** One streamed OCR result chunk; `streamText()` extracts its non-empty text. */
+export type OcrChunk = Data<i.OCRChunk>;
+/** Transcription model and audio Buffer in `file`, with optional filename, MIME content type, language, and model settings. */
+export type TranscriptionInput = Input<i.AudioTranscriptionRequest, "file" | "model">;
+/** Translation model and audio Buffer in `file`, with optional filename, MIME content type, and model settings. */
+export type TranslationInput = Input<i.AudioTranslationRequest, "file" | "model">;
+/** Full transcription/translation output. Timing, language, words, and segments are populated when supplied by the model. */
+export type AudioText = Data<i.AudioTextResponse>;
+/** Speech model and text in `input`, plus optional voice, format, speed, instructions, and model-specific JSON settings. */
+export type SpeechInput = Input<i.SpeechRequest, "model" | "input">;
+/** Audio bytes in `data` as a Node Buffer, with the server-provided MIME `contentType`. Used for both collected speech and individual chunks. */
+export type AudioData = Data<i.AudioChunk>;
+/** Voice clone request with model, name, sample Buffer, consent signer, and consent date. Optional filename/contentType describe the sample. */
+export type VoiceInput = Input<i.VoiceCloneRequest, "model" | "name" | "sample" | "consentSignedBy" | "consentDate">;
+/** A voice clone record with its identifier and server-reported lifecycle status. */
+export type Voice = Data<i.VoiceClone>;
+/** Authenticated account information, including organizations and `defaultOrgId` for constructing an organization scope. */
+export type User = Data<p.CurrentUser>;
+/** Organization metadata. Use `client.org(organization.id)` to access its nested resources. */
+export type Organization = Data<p.Org>;
+/** An organization membership with account identifier and role. */
+export type OrganizationMember = Data<p.OrgMember>;
+/** Organization display name and optional globally unique slug; the server allocates an omitted slug. */
+export type OrganizationInput = Input<p.CreateOrgRequest, "name">;
+/** A durable product entitlement request and its current review/access status. */
+export type ProductAccessRequest = Data<p.ProductAccessRequest>;
+/** Product entitlement request details. Organization context is supplied by the scope; omitted contact email uses the authenticated account. */
+export type ProductAccessInput = Input<p.RequestProductAccessRequest, "product", "orgId">;
+/** Optional product and result limit for access requests. The server defaults to 25 records and caps the limit at 100. */
+export type ProductAccessFilter = Input<p.ListProductAccessRequestsRequest, never, "orgId">;
+/** API key metadata without its plaintext secret. List and revoke methods return this shape. */
+export type ApiKey = Data<p.ApiKey>;
+/** API key metadata plus a one-time `secret`. Persist the secret at creation; it is not returned by subsequent list calls. */
+export type CreatedApiKey = ApiKey & {
+    /** Plaintext API key returned only at creation. Store it securely for authentication. */
+    secret: string;
+};
+/** Optional label, product scopes, and allowed model aliases. Empty model restrictions inherit organization policy; empty scopes use the server's inference default. */
+export type ApiKeyInput = Input<p.CreateApiKeyRequest, never, "orgId">;
+/** Effective inference limits and model policy. Optional absent limits are unlimited; 64-bit budgets use bigint. */
+export type QuotaPolicy = Data<p.QuotaPolicy>;
+/** Complete quota policy replacement. Include every limit to retain; omitted limits become unlimited. Supply model aliases when `allowAllModels` is false. */
+export type QuotaPolicyInput = Input<p.UpdateQuotaPolicyRequest, "allowAllModels", "orgId">;
+/** An inference usage record. 64-bit IDs and counters are bigint so they remain lossless. */
+export type UsageEvent = Data<p.UsageEvent>;
+/** Aggregate organization usage with lossless bigint counters. */
+export type UsageSummary = Data<p.UsageSummary>;
+/** Recorded desired and observed state of managed compute. A creation result does not imply the resource is ready. */
+export type ComputeResource = Data<p.ProvisionedResource>;
+/** Desired inference service configuration with a DNS-label name and model alias; the organization is supplied by the scope. */
+export type InferenceServiceInput = Input<p.CreateInferenceServiceRequest, "name" | "modelAlias", "orgId">;
+/** Desired agent host configuration with a DNS-label name and container image. Extension `spec` must not contain secrets. */
+export type AgentHostInput = Input<p.CreateAgentHostRequest, "name" | "image", "orgId">;
+/** Desired container job configuration. `command` is argv without shell expansion; `timeoutSeconds` controls server execution, separately from client `timeoutMs`. */
+export type JobInput = Input<p.CreateJobRequest, "name" | "image", "orgId">;
+/** An organization storage bucket record, including its stable identifier. */
+export type StorageBucket = Data<p.StorageBucket>;
+/** Bucket credential metadata without its plaintext secret. */
+export type StorageCredential = Data<p.StorageCredential>;
+/** Bucket credential metadata plus access key, one-time secret, endpoint, and region. Persist the secret when created. */
+export type CreatedStorageCredential = StorageCredential & {
+    /** Access key identifier used by an S3-compatible client. */
+    accessKeyId: string;
+    /** One-time plaintext secret. It cannot be retrieved by listing credentials. */
+    secretAccessKey: string;
+    /** Storage service endpoint for the issued credentials. */
+    endpoint: string;
+    /** Storage region used with the issued credentials. */
+    region: string;
+};
+/** An organization's hosted Git repository record. */
+export type GitRepository = Data<p.GitRepository>;
+/** Hosted repository creation settings; the organization is supplied by the scope. */
+export type GitRepositoryInput = Input<p.CreateGitRepositoryRequest, "name", "orgId">;
+/** The authenticated account's hosted Git identity and reconciliation/access state. */
+export type GitAccess = Data<p.HostedGitAccess>;
+/** Readable sandbox lifecycle state. `unknown` represents an unspecified or unrecognized server enum value. */
+export type SandboxStatus = "starting" | "ready" | "busy" | "stopping" | "stopped" | "failed" | "expired" | "deleted" | "unknown";
+/** Readable template build/deletion state. `unknown` represents an unspecified or unrecognized server enum value. */
+export type TemplateStatus = "pending" | "building" | "ready" | "failed" | "deleting" | "deleted" | "unknown";
+/** Readable execution state. Only `running` is polled; known terminal states, including failures, are returned for inspection. */
+export type ExecutionStatus = "running" | "succeeded" | "failed" | "timed_out" | "cancelled" | "unknown";
+/** Source language used by the template. `unknown` represents an unspecified or unrecognized server value. */
+export type SandboxRuntime = "python" | "node" | "unknown";
+/** A sandbox snapshot with readable status/runtime and Date timestamps. Available through `sandbox.info` and `sandbox.toJSON()`. */
+export type SandboxData = Omit<s.CodeSandbox, "status" | "runtime"> & {
+    status: SandboxStatus;
+    runtime: SandboxRuntime;
+};
+/** A template snapshot with readable status/runtime, build information, and Date timestamps. */
+export type TemplateData = Omit<s.SandboxTemplate, "status" | "runtime"> & {
+    status: TemplateStatus;
+    runtime: SandboxRuntime;
+};
+/** An execution snapshot with readable status, retained output, exit code, truncation flag, and timestamps. */
+export type ExecutionData = Omit<s.Execution, "status"> & {
+    status: ExecutionStatus;
+};
+/** Sandbox creation settings. `template` accepts a visible ID or alias; `timeoutSeconds` is server lifetime. An omitted idempotency key is generated for recovery. */
+export type SandboxInput = Input<s.CreateCodeSandboxRequest, "template", "orgId">;
+/** Optional stdin, server execution limit in `timeoutSeconds`, and idempotency key. Client wait duration belongs in request options as `timeoutMs`; omitted keys are generated. */
+export type ExecutionInput = Input<s.ExecuteRequest, never, "orgId" | "sandboxId" | "code">;
+/** Custom template alias, built-in base alias, and exactly one dependency manifest string. An omitted idempotency key is generated for recovery. */
+export type TemplateInput = Input<s.CreateSandboxTemplateRequest, "alias" | "baseTemplateAlias", "orgId" | "dependencyFile"> & ({
+    /** Contents of requirements.txt, not a file path. Choose exactly one manifest. */
+    requirementsTxt: string;
+    packageJson?: never;
+    pyprojectToml?: never;
+} | {
+    /** Contents of package.json as a JSON string, not an object or file path. */
+    packageJson: string;
+    requirementsTxt?: never;
+    pyprojectToml?: never;
+} | {
+    /** Contents of pyproject.toml, not a file path. Choose exactly one manifest. */
+    pyprojectToml: string;
+    requirementsTxt?: never;
+    packageJson?: never;
+});

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,157 @@
 {
   "name": "@tarkahq/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "The official JavaScript and TypeScript SDK for the Tarka gRPC API",
+  "license": "Apache-2.0",
+  "author": "Tarka",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./grpc": {
+      "import": {
+        "types": "./dist/esm/grpc.d.ts",
+        "default": "./dist/esm/grpc.js"
+      },
+      "require": {
+        "types": "./dist/cjs/grpc.d.ts",
+        "default": "./dist/cjs/grpc.js"
+      }
+    },
+    "./grpc/inference/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/inference/v1/inference.d.ts",
+        "default": "./dist/esm/generated/tarka/inference/v1/inference.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/inference/v1/inference.d.ts",
+        "default": "./dist/cjs/generated/tarka/inference/v1/inference.js"
+      }
+    },
+    "./grpc/provisioning/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/provisioning/v1/provisioning.d.ts",
+        "default": "./dist/esm/generated/tarka/provisioning/v1/provisioning.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/provisioning/v1/provisioning.d.ts",
+        "default": "./dist/cjs/generated/tarka/provisioning/v1/provisioning.js"
+      }
+    },
+    "./grpc/sandboxes/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/provisioning/v1/sandbox.d.ts",
+        "default": "./dist/esm/generated/tarka/provisioning/v1/sandbox.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/provisioning/v1/sandbox.d.ts",
+        "default": "./dist/cjs/generated/tarka/provisioning/v1/sandbox.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./grpc/iam/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/iam/v1/iam.d.ts",
+        "default": "./dist/esm/generated/tarka/iam/v1/iam.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/iam/v1/iam.d.ts",
+        "default": "./dist/cjs/generated/tarka/iam/v1/iam.js"
+      }
+    },
+    "./grpc/gateway/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/gateway/v1/gateway.d.ts",
+        "default": "./dist/esm/generated/tarka/gateway/v1/gateway.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/gateway/v1/gateway.d.ts",
+        "default": "./dist/cjs/generated/tarka/gateway/v1/gateway.js"
+      }
+    },
+    "./grpc/access/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/access/v1/access.d.ts",
+        "default": "./dist/esm/generated/tarka/access/v1/access.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/access/v1/access.d.ts",
+        "default": "./dist/cjs/generated/tarka/access/v1/access.js"
+      }
+    },
+    "./grpc/channels/v1": {
+      "import": {
+        "types": "./dist/esm/generated/tarka/channels/v1/channels.d.ts",
+        "default": "./dist/esm/generated/tarka/channels/v1/channels.js"
+      },
+      "require": {
+        "types": "./dist/cjs/generated/tarka/channels/v1/channels.d.ts",
+        "default": "./dist/cjs/generated/tarka/channels/v1/channels.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "api-source.json"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TarkaHQ/sdk-javascript.git"
+  },
+  "homepage": "https://github.com/TarkaHQ/sdk-javascript#readme",
+  "bugs": "https://github.com/TarkaHQ/sdk-javascript/issues",
+  "keywords": [
+    "tarka",
+    "sdk",
+    "grpc",
+    "typescript",
+    "inference",
+    "sandboxes"
+  ],
+  "scripts": {
+    "generate": "node scripts/generate.mjs",
+    "check:generated": "node scripts/generate.mjs --check",
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
+    "test": "tsx --test tests/*.test.ts",
+    "test:package": "node scripts/test-package.mjs",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "verify": "npm run format:check && npm run typecheck && npm test && npm run build && npm run test:package",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.16.0",
+    "@grpc/grpc-js": "^1.14.5"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4",
+    "grpc-tools": "1.13.1",
+    "prettier": "3.9.9",
+    "ts-proto": "2.12.4",
+    "tsx": "4.23.15",
+    "typescript": "5.9.3"
+  }
+}