@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/providers/provider-thinking.js

@@ -0,0 +1,64 @@
+import { thinkingRequestFormatFor } from "./thinking-request.js";
+import { requestableReasoningOptions, runThinkingLevel } from "../thinking.js";
+import { ModelRouterLanguageModel, getModelReasoningOptions } from "@mastra/core/llm";
+import { wrapLanguageModel } from "ai";
+//#region src/providers/provider-thinking.ts
+function providerThinkingOptions(routedModelId, level) {
+	const format = thinkingRequestFormatFor(routedModelId);
+	if (!format || !level) return void 0;
+	const catalogOptions = getModelReasoningOptions(routedModelId);
+	const requestable = requestableReasoningOptions(routedModelId, catalogOptions);
+	const runLevel = runThinkingLevel(routedModelId, level, catalogOptions);
+	if (!requestable?.length || runLevel === "off") return void 0;
+	const effortOptions = format.sendEffort?.(runLevel);
+	const options = requestable.some((option) => option.type === "effort") ? effortOptions : format.enableThinking;
+	if (!options) return void 0;
+	const controlKeys = /* @__PURE__ */ new Set([...Object.keys(effortOptions ?? {}), ...Object.keys(format.enableThinking ?? {})]);
+	return {
+		optionsKey: format.optionsKey,
+		options,
+		controlKeys
+	};
+}
+function withThinkingOptions(callOptions, thinking) {
+	if (!thinking) return callOptions;
+	const callerOptions = callOptions.providerOptions?.[thinking.optionsKey] ?? {};
+	if (Object.keys(callerOptions).some((key) => thinking.controlKeys.has(key))) return callOptions;
+	return {
+		...callOptions,
+		providerOptions: {
+			...callOptions.providerOptions,
+			[thinking.optionsKey]: {
+				...callerOptions,
+				...thinking.options
+			}
+		}
+	};
+}
+function withThinkingOptionsModel(model, thinking) {
+	if (!thinking) return model;
+	return wrapLanguageModel({
+		model,
+		middleware: {
+			specificationVersion: "v3",
+			transformParams: async ({ params }) => withThinkingOptions(params, thinking)
+		}
+	});
+}
+var ModelRouterLanguageModelWithThinking = class extends ModelRouterLanguageModel {
+	#thinking;
+	constructor(config, thinking) {
+		super(config);
+		this.#thinking = thinking;
+	}
+	doGenerate(options) {
+		return super.doGenerate(withThinkingOptions(options, this.#thinking));
+	}
+	doStream(options) {
+		return super.doStream(withThinkingOptions(options, this.#thinking));
+	}
+};
+//#endregion
+export { ModelRouterLanguageModelWithThinking, providerThinkingOptions, withThinkingOptionsModel };
+
+//# sourceMappingURL=provider-thinking.js.map

package/dist/providers/provider-thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-thinking.js","names":["#thinking"],"sources":["../../src/providers/provider-thinking.ts"],"sourcesContent":["import { getModelReasoningOptions, ModelRouterLanguageModel } from '@mastra/core/llm';\nimport { wrapLanguageModel } from 'ai';\nimport type { JSONValue } from 'ai';\nimport { requestableReasoningOptions, runThinkingLevel } from '../thinking.js';\nimport type { ThinkingLevelSetting } from '../thinking.js';\nimport { thinkingRequestFormatFor } from './thinking-request.js';\n\ntype ProviderOptions = Record<string, Record<string, JSONValue | undefined>>;\n\nexport interface ProviderThinkingOptions {\n  optionsKey: string;\n  options: Record<string, JSONValue>;\n  controlKeys: ReadonlySet<string>;\n}\n\nexport function providerThinkingOptions(\n  routedModelId: string,\n  level: ThinkingLevelSetting | undefined,\n): ProviderThinkingOptions | undefined {\n  const format = thinkingRequestFormatFor(routedModelId);\n  if (!format || !level) return undefined;\n  const catalogOptions = getModelReasoningOptions(routedModelId);\n  const requestable = requestableReasoningOptions(routedModelId, catalogOptions);\n  const runLevel = runThinkingLevel(routedModelId, level, catalogOptions);\n  if (!requestable?.length || runLevel === 'off') return undefined;\n  const effortOptions = format.sendEffort?.(runLevel);\n  const sendsEffort = requestable.some(option => option.type === 'effort');\n  const options = sendsEffort ? effortOptions : format.enableThinking;\n  if (!options) return undefined;\n  const controlKeys = new Set([...Object.keys(effortOptions ?? {}), ...Object.keys(format.enableThinking ?? {})]);\n  return { optionsKey: format.optionsKey, options, controlKeys };\n}\n\nfunction withThinkingOptions<CallOptions extends { providerOptions?: ProviderOptions }>(\n  callOptions: CallOptions,\n  thinking: ProviderThinkingOptions | undefined,\n): CallOptions {\n  if (!thinking) return callOptions;\n  const callerOptions = callOptions.providerOptions?.[thinking.optionsKey] ?? {};\n  const callerSetThinking = Object.keys(callerOptions).some(key => thinking.controlKeys.has(key));\n  if (callerSetThinking) return callOptions;\n  return {\n    ...callOptions,\n    providerOptions: {\n      ...callOptions.providerOptions,\n      [thinking.optionsKey]: { ...callerOptions, ...thinking.options },\n    },\n  };\n}\n\ntype AiSdkLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model'];\n\nexport function withThinkingOptionsModel(\n  model: AiSdkLanguageModel,\n  thinking: ProviderThinkingOptions | undefined,\n): AiSdkLanguageModel {\n  if (!thinking) return model;\n  return wrapLanguageModel({\n    model,\n    middleware: {\n      specificationVersion: 'v3',\n      transformParams: async ({ params }) => withThinkingOptions(params, thinking),\n    },\n  });\n}\n\ntype RouterConfig = ConstructorParameters<typeof ModelRouterLanguageModel>[0];\ntype RouterCallOptions = Parameters<ModelRouterLanguageModel['doStream']>[0];\ntype RouterCallResult = ReturnType<ModelRouterLanguageModel['doStream']>;\n\nexport class ModelRouterLanguageModelWithThinking extends ModelRouterLanguageModel {\n  readonly #thinking: ProviderThinkingOptions | undefined;\n\n  constructor(config: RouterConfig, thinking: ProviderThinkingOptions | undefined) {\n    super(config);\n    this.#thinking = thinking;\n  }\n\n  override doGenerate(options: RouterCallOptions): RouterCallResult {\n    return super.doGenerate(withThinkingOptions(options, this.#thinking));\n  }\n\n  override doStream(options: RouterCallOptions): RouterCallResult {\n    return super.doStream(withThinkingOptions(options, this.#thinking));\n  }\n}\n"],"mappings":";;;;;AAeA,SAAgB,wBACd,eACA,OACqC;CACrC,MAAM,SAAS,yBAAyB,aAAa;CACrD,IAAI,CAAC,UAAU,CAAC,OAAO,OAAO,KAAA;CAC9B,MAAM,iBAAiB,yBAAyB,aAAa;CAC7D,MAAM,cAAc,4BAA4B,eAAe,cAAc;CAC7E,MAAM,WAAW,iBAAiB,eAAe,OAAO,cAAc;CACtE,IAAI,CAAC,aAAa,UAAU,aAAa,OAAO,OAAO,KAAA;CACvD,MAAM,gBAAgB,OAAO,aAAa,QAAQ;CAElD,MAAM,UADc,YAAY,MAAK,WAAU,OAAO,SAAS,QACrC,IAAI,gBAAgB,OAAO;CACrD,IAAI,CAAC,SAAS,OAAO,KAAA;CACrB,MAAM,8BAAc,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,iBAAiB,CAAC,CAAC,GAAG,GAAG,OAAO,KAAK,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC;CAC9G,OAAO;EAAE,YAAY,OAAO;EAAY;EAAS;CAAY;AAC/D;AAEA,SAAS,oBACP,aACA,UACa;CACb,IAAI,CAAC,UAAU,OAAO;CACtB,MAAM,gBAAgB,YAAY,kBAAkB,SAAS,eAAe,CAAC;CAE7E,IAD0B,OAAO,KAAK,aAAa,CAAC,CAAC,MAAK,QAAO,SAAS,YAAY,IAAI,GAAG,CACzE,GAAG,OAAO;CAC9B,OAAO;EACL,GAAG;EACH,iBAAiB;GACf,GAAG,YAAY;IACd,SAAS,aAAa;IAAE,GAAG;IAAe,GAAG,SAAS;GAAQ;EACjE;CACF;AACF;AAIA,SAAgB,yBACd,OACA,UACoB;CACpB,IAAI,CAAC,UAAU,OAAO;CACtB,OAAO,kBAAkB;EACvB;EACA,YAAY;GACV,sBAAsB;GACtB,iBAAiB,OAAO,EAAE,aAAa,oBAAoB,QAAQ,QAAQ;EAC7E;CACF,CAAC;AACH;AAMA,IAAa,uCAAb,cAA0D,yBAAyB;CACjF;CAEA,YAAY,QAAsB,UAA+C;EAC/E,MAAM,MAAM;EACZ,KAAKA,YAAY;CACnB;CAEA,WAAoB,SAA8C;EAChE,OAAO,MAAM,WAAW,oBAAoB,SAAS,KAAKA,SAAS,CAAC;CACtE;CAEA,SAAkB,SAA8C;EAC9D,OAAO,MAAM,SAAS,oBAAoB,SAAS,KAAKA,SAAS,CAAC;CACpE;AACF"}

package/dist/providers/thinking-request.d.ts

@@ -0,0 +1,14 @@
+import type { JSONValue } from 'ai';
+import type { ActiveThinkingLevel } from '../thinking.js';
+type ThinkingProviderOptions = Record<string, JSONValue>;
+export interface ThinkingRequestFormat {
+    optionsKey: string;
+    sendEffort?: (effort: ActiveThinkingLevel) => ThinkingProviderOptions;
+    acceptedEfforts?: readonly ActiveThinkingLevel[];
+    enableThinking?: ThinkingProviderOptions;
+}
+export declare function isThinkingAdapterProvider(provider: string): boolean;
+export declare function isRoutedWithoutThinking(modelId: string): boolean;
+export declare function thinkingRequestFormatFor(modelId: string): ThinkingRequestFormat | undefined;
+export {};
+//# sourceMappingURL=thinking-request.d.ts.map

package/dist/providers/thinking-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-request.d.ts","sourceRoot":"","sources":["../../src/providers/thinking-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,KAAK,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEzD,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,uBAAuB,CAAC;IACtE,eAAe,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,cAAc,CAAC,EAAE,uBAAuB,CAAC;CAC1C;AAyCD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEnE;AASD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGhE;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAM3F"}

package/dist/providers/thinking-request.js

@@ -0,0 +1,90 @@
+import { MASTRA_GATEWAY_PREFIX, stripMastraGatewayPrefix } from "./model-ids.js";
+//#region src/providers/thinking-request.ts
+const LOW_TO_HIGH = [
+	"low",
+	"medium",
+	"high"
+];
+const sendReasoningEffort = (reasoningEffort) => ({ reasoningEffort });
+const ENABLE_REASONING = { reasoning: { enabled: true } };
+const OPENROUTER_FORMAT = {
+	optionsKey: "openrouter",
+	sendEffort: (effort) => ({ reasoning: { effort } }),
+	enableThinking: ENABLE_REASONING
+};
+const REQUEST_FORMATS_BY_PROVIDER = {
+	deepseek: {
+		optionsKey: "deepseek",
+		sendEffort: sendReasoningEffort,
+		enableThinking: { thinking: { type: "enabled" } }
+	},
+	openrouter: OPENROUTER_FORMAT,
+	alibaba: {
+		optionsKey: "alibaba",
+		enableThinking: { enableThinking: true }
+	},
+	groq: {
+		optionsKey: "groq",
+		sendEffort: sendReasoningEffort,
+		acceptedEfforts: LOW_TO_HIGH
+	},
+	mistral: {
+		optionsKey: "mistral",
+		sendEffort: sendReasoningEffort,
+		acceptedEfforts: ["high"]
+	},
+	xai: {
+		optionsKey: "xai",
+		sendEffort: sendReasoningEffort,
+		acceptedEfforts: LOW_TO_HIGH
+	},
+	togetherai: {
+		optionsKey: "togetherai",
+		sendEffort: sendReasoningEffort,
+		acceptedEfforts: LOW_TO_HIGH,
+		enableThinking: ENABLE_REASONING
+	},
+	deepinfra: {
+		optionsKey: "deepinfra",
+		sendEffort: sendReasoningEffort,
+		acceptedEfforts: LOW_TO_HIGH,
+		enableThinking: ENABLE_REASONING
+	},
+	cerebras: {
+		optionsKey: "cerebras",
+		sendEffort: sendReasoningEffort
+	},
+	perplexity: {
+		optionsKey: "perplexity",
+		sendEffort: (effort) => ({ reasoning_effort: effort })
+	}
+};
+const THINKING_ADAPTER_PROVIDERS = /* @__PURE__ */ new Set([
+	"anthropic",
+	"openai",
+	"google"
+]);
+function isThinkingAdapterProvider(provider) {
+	return THINKING_ADAPTER_PROVIDERS.has(provider);
+}
+const PROVIDERS_ROUTED_WITHOUT_THINKING = /* @__PURE__ */ new Set([
+	"github-copilot",
+	"kimi-for-coding",
+	"moonshotai",
+	"amazon-bedrock"
+]);
+function isRoutedWithoutThinking(modelId) {
+	const [provider = ""] = stripMastraGatewayPrefix(modelId).split("/");
+	return PROVIDERS_ROUTED_WITHOUT_THINKING.has(provider);
+}
+function thinkingRequestFormatFor(modelId) {
+	const routedThroughMastraGateway = modelId.startsWith(MASTRA_GATEWAY_PREFIX);
+	const [provider = ""] = stripMastraGatewayPrefix(modelId).split("/");
+	if (isThinkingAdapterProvider(provider)) return void 0;
+	if (routedThroughMastraGateway) return OPENROUTER_FORMAT;
+	return REQUEST_FORMATS_BY_PROVIDER[provider.includes("alibaba") ? "alibaba" : provider];
+}
+//#endregion
+export { isRoutedWithoutThinking, isThinkingAdapterProvider, thinkingRequestFormatFor };
+
+//# sourceMappingURL=thinking-request.js.map

package/dist/providers/thinking-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-request.js","names":[],"sources":["../../src/providers/thinking-request.ts"],"sourcesContent":["import type { JSONValue } from 'ai';\nimport type { ActiveThinkingLevel } from '../thinking.js';\nimport { MASTRA_GATEWAY_PREFIX, stripMastraGatewayPrefix } from './model-ids.js';\n\ntype ThinkingProviderOptions = Record<string, JSONValue>;\n\nexport interface ThinkingRequestFormat {\n  optionsKey: string;\n  sendEffort?: (effort: ActiveThinkingLevel) => ThinkingProviderOptions;\n  acceptedEfforts?: readonly ActiveThinkingLevel[];\n  enableThinking?: ThinkingProviderOptions;\n}\n\nconst LOW_TO_HIGH: readonly ActiveThinkingLevel[] = ['low', 'medium', 'high'];\nconst sendReasoningEffort = (reasoningEffort: ActiveThinkingLevel): ThinkingProviderOptions => ({ reasoningEffort });\nconst ENABLE_REASONING: ThinkingProviderOptions = { reasoning: { enabled: true } };\n\nconst OPENROUTER_FORMAT: ThinkingRequestFormat = {\n  optionsKey: 'openrouter',\n  sendEffort: effort => ({ reasoning: { effort } }),\n  enableThinking: ENABLE_REASONING,\n};\n\nconst REQUEST_FORMATS_BY_PROVIDER: Partial<Record<string, ThinkingRequestFormat>> = {\n  deepseek: {\n    optionsKey: 'deepseek',\n    sendEffort: sendReasoningEffort,\n    enableThinking: { thinking: { type: 'enabled' } },\n  },\n  openrouter: OPENROUTER_FORMAT,\n  alibaba: { optionsKey: 'alibaba', enableThinking: { enableThinking: true } },\n  groq: { optionsKey: 'groq', sendEffort: sendReasoningEffort, acceptedEfforts: LOW_TO_HIGH },\n  mistral: { optionsKey: 'mistral', sendEffort: sendReasoningEffort, acceptedEfforts: ['high'] },\n  xai: { optionsKey: 'xai', sendEffort: sendReasoningEffort, acceptedEfforts: LOW_TO_HIGH },\n  togetherai: {\n    optionsKey: 'togetherai',\n    sendEffort: sendReasoningEffort,\n    acceptedEfforts: LOW_TO_HIGH,\n    enableThinking: ENABLE_REASONING,\n  },\n  deepinfra: {\n    optionsKey: 'deepinfra',\n    sendEffort: sendReasoningEffort,\n    acceptedEfforts: LOW_TO_HIGH,\n    enableThinking: ENABLE_REASONING,\n  },\n  cerebras: { optionsKey: 'cerebras', sendEffort: sendReasoningEffort },\n  perplexity: { optionsKey: 'perplexity', sendEffort: effort => ({ reasoning_effort: effort }) },\n};\n\nconst THINKING_ADAPTER_PROVIDERS: ReadonlySet<string> = new Set(['anthropic', 'openai', 'google']);\n\nexport function isThinkingAdapterProvider(provider: string): boolean {\n  return THINKING_ADAPTER_PROVIDERS.has(provider);\n}\n\nconst PROVIDERS_ROUTED_WITHOUT_THINKING: ReadonlySet<string> = new Set([\n  'github-copilot',\n  'kimi-for-coding',\n  'moonshotai',\n  'amazon-bedrock',\n]);\n\nexport function isRoutedWithoutThinking(modelId: string): boolean {\n  const [provider = ''] = stripMastraGatewayPrefix(modelId).split('/');\n  return PROVIDERS_ROUTED_WITHOUT_THINKING.has(provider);\n}\n\nexport function thinkingRequestFormatFor(modelId: string): ThinkingRequestFormat | undefined {\n  const routedThroughMastraGateway = modelId.startsWith(MASTRA_GATEWAY_PREFIX);\n  const [provider = ''] = stripMastraGatewayPrefix(modelId).split('/');\n  if (isThinkingAdapterProvider(provider)) return undefined;\n  if (routedThroughMastraGateway) return OPENROUTER_FORMAT;\n  return REQUEST_FORMATS_BY_PROVIDER[provider.includes('alibaba') ? 'alibaba' : provider];\n}\n"],"mappings":";;AAaA,MAAM,cAA8C;CAAC;CAAO;CAAU;AAAM;AAC5E,MAAM,uBAAuB,qBAAmE,EAAE,gBAAgB;AAClH,MAAM,mBAA4C,EAAE,WAAW,EAAE,SAAS,KAAK,EAAE;AAEjF,MAAM,oBAA2C;CAC/C,YAAY;CACZ,aAAY,YAAW,EAAE,WAAW,EAAE,OAAO,EAAE;CAC/C,gBAAgB;AAClB;AAEA,MAAM,8BAA8E;CAClF,UAAU;EACR,YAAY;EACZ,YAAY;EACZ,gBAAgB,EAAE,UAAU,EAAE,MAAM,UAAU,EAAE;CAClD;CACA,YAAY;CACZ,SAAS;EAAE,YAAY;EAAW,gBAAgB,EAAE,gBAAgB,KAAK;CAAE;CAC3E,MAAM;EAAE,YAAY;EAAQ,YAAY;EAAqB,iBAAiB;CAAY;CAC1F,SAAS;EAAE,YAAY;EAAW,YAAY;EAAqB,iBAAiB,CAAC,MAAM;CAAE;CAC7F,KAAK;EAAE,YAAY;EAAO,YAAY;EAAqB,iBAAiB;CAAY;CACxF,YAAY;EACV,YAAY;EACZ,YAAY;EACZ,iBAAiB;EACjB,gBAAgB;CAClB;CACA,WAAW;EACT,YAAY;EACZ,YAAY;EACZ,iBAAiB;EACjB,gBAAgB;CAClB;CACA,UAAU;EAAE,YAAY;EAAY,YAAY;CAAoB;CACpE,YAAY;EAAE,YAAY;EAAc,aAAY,YAAW,EAAE,kBAAkB,OAAO;CAAG;AAC/F;AAEA,MAAM,6CAAkD,IAAI,IAAI;CAAC;CAAa;CAAU;AAAQ,CAAC;AAEjG,SAAgB,0BAA0B,UAA2B;CACnE,OAAO,2BAA2B,IAAI,QAAQ;AAChD;AAEA,MAAM,oDAAyD,IAAI,IAAI;CACrE;CACA;CACA;CACA;AACF,CAAC;AAED,SAAgB,wBAAwB,SAA0B;CAChE,MAAM,CAAC,WAAW,MAAM,yBAAyB,OAAO,CAAC,CAAC,MAAM,GAAG;CACnE,OAAO,kCAAkC,IAAI,QAAQ;AACvD;AAEA,SAAgB,yBAAyB,SAAoD;CAC3F,MAAM,6BAA6B,QAAQ,WAAW,qBAAqB;CAC3E,MAAM,CAAC,WAAW,MAAM,yBAAyB,OAAO,CAAC,CAAC,MAAM,GAAG;CACnE,IAAI,0BAA0B,QAAQ,GAAG,OAAO,KAAA;CAChD,IAAI,4BAA4B,OAAO;CACvC,OAAO,4BAA4B,SAAS,SAAS,SAAS,IAAI,YAAY;AAChF"}

package/dist/providers/xai.d.ts

@@ -0,0 +1,33 @@
+/**
+ * xAI (Grok) OAuth Provider
+ *
+ * Uses OAuth tokens from AuthStorage to authenticate with the xAI API.
+ * The xAI API speaks an OpenAI-compatible chat format, and the OAuth access
+ * token is accepted as a bearer API key, so we plug `@ai-sdk/openai-compatible`
+ * into `https://api.x.ai/v1` with a custom fetch that injects the (auto-refreshed)
+ * access token.
+ */
+import type { OpenAICompatibleProvider } from '@ai-sdk/openai-compatible';
+import { AuthStorage } from '../auth/storage.js';
+import type { CredentialStore } from '../auth/types.js';
+/** Get or create the shared AuthStorage instance. */
+export declare function getAuthStorage(): AuthStorage;
+/** Set a custom AuthStorage instance (useful for tests / TUI integration). */
+export declare function setAuthStorage(storage: AuthStorage | undefined): void;
+/**
+ * Build a fetch wrapper that authenticates with xAI OAuth.
+ * Injects the access token (auto-refreshed by AuthStorage) as a bearer token,
+ * preserving non-auth headers from the caller.
+ */
+export declare function buildXAIOAuthFetch(opts?: {
+    authStorage?: CredentialStore;
+}): typeof fetch;
+/**
+ * Creates an xAI model using OAuth authentication.
+ * Uses OAuth tokens from AuthStorage (auto-refreshes when needed).
+ */
+export declare function xaiProvider(modelId: string, options?: {
+    headers?: Record<string, string>;
+    authStorage?: CredentialStore;
+}): ReturnType<OpenAICompatibleProvider['chatModel']>;
+//# sourceMappingURL=xai.d.ts.map

package/dist/providers/xai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xai.d.ts","sourceRoot":"","sources":["../../src/providers/xai.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAQxD,qDAAqD;AACrD,wBAAgB,cAAc,IAAI,WAAW,CAK5C;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAErE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,eAAe,CAAA;CAAO,GAAG,OAAO,KAAK,CAsC7F;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,WAAW,CAAC,EAAE,eAAe,CAAA;CAAE,GAC5E,UAAU,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC,CASnD"}

package/dist/providers/xai.js

@@ -0,0 +1,71 @@
+import { AuthStorage } from "../auth/storage.js";
+import { ProviderAuthRequiredError } from "../auth/provider-auth-error.js";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+//#region src/providers/xai.ts
+/**
+* xAI (Grok) OAuth Provider
+*
+* Uses OAuth tokens from AuthStorage to authenticate with the xAI API.
+* The xAI API speaks an OpenAI-compatible chat format, and the OAuth access
+* token is accepted as a bearer API key, so we plug `@ai-sdk/openai-compatible`
+* into `https://api.x.ai/v1` with a custom fetch that injects the (auto-refreshed)
+* access token.
+*/
+const XAI_PROVIDER_ID = "xai";
+const XAI_BASE_URL = "https://api.x.ai/v1";
+let authStorageInstance = null;
+/** Get or create the shared AuthStorage instance. */
+function getAuthStorage() {
+	if (!authStorageInstance) authStorageInstance = new AuthStorage();
+	return authStorageInstance;
+}
+/** Set a custom AuthStorage instance (useful for tests / TUI integration). */
+function setAuthStorage(storage) {
+	authStorageInstance = storage ?? null;
+}
+/**
+* Build a fetch wrapper that authenticates with xAI OAuth.
+* Injects the access token (auto-refreshed by AuthStorage) as a bearer token,
+* preserving non-auth headers from the caller.
+*/
+function buildXAIOAuthFetch(opts = {}) {
+	return (async (url, init) => {
+		const storage = opts.authStorage ?? getAuthStorage();
+		storage.reload();
+		const cred = storage.get(XAI_PROVIDER_ID);
+		if (!cred || cred.type !== "oauth") throw new ProviderAuthRequiredError("Not logged in to xAI.");
+		const accessToken = await storage.getApiKey(XAI_PROVIDER_ID);
+		if (!accessToken) throw new ProviderAuthRequiredError("Failed to refresh the xAI token.");
+		const headers = new Headers(url instanceof Request ? url.headers : void 0);
+		if (init?.headers) new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+		headers.delete("authorization");
+		headers.delete("x-api-key");
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		try {
+			return await fetch(url, {
+				...init,
+				headers
+			});
+		} catch (error) {
+			if (error && typeof error === "object") Object.assign(error, { requestUrl: url instanceof URL ? url.toString() : typeof url === "string" ? url : url.url });
+			throw error;
+		}
+	});
+}
+/**
+* Creates an xAI model using OAuth authentication.
+* Uses OAuth tokens from AuthStorage (auto-refreshes when needed).
+*/
+function xaiProvider(modelId, options) {
+	return createOpenAICompatible({
+		name: XAI_PROVIDER_ID,
+		baseURL: XAI_BASE_URL,
+		apiKey: "oauth-placeholder",
+		headers: options?.headers,
+		fetch: buildXAIOAuthFetch({ authStorage: options?.authStorage })
+	}).chatModel(modelId);
+}
+//#endregion
+export { buildXAIOAuthFetch, getAuthStorage, setAuthStorage, xaiProvider };
+
+//# sourceMappingURL=xai.js.map

package/dist/providers/xai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xai.js","names":[],"sources":["../../src/providers/xai.ts"],"sourcesContent":["/**\n * xAI (Grok) OAuth Provider\n *\n * Uses OAuth tokens from AuthStorage to authenticate with the xAI API.\n * The xAI API speaks an OpenAI-compatible chat format, and the OAuth access\n * token is accepted as a bearer API key, so we plug `@ai-sdk/openai-compatible`\n * into `https://api.x.ai/v1` with a custom fetch that injects the (auto-refreshed)\n * access token.\n */\n\nimport { createOpenAICompatible } from '@ai-sdk/openai-compatible';\nimport type { OpenAICompatibleProvider } from '@ai-sdk/openai-compatible';\nimport { ProviderAuthRequiredError } from '../auth/provider-auth-error.js';\nimport { AuthStorage } from '../auth/storage.js';\nimport type { CredentialStore } from '../auth/types.js';\n\nconst XAI_PROVIDER_ID = 'xai';\nconst XAI_BASE_URL = 'https://api.x.ai/v1';\n\n// Singleton auth storage instance (shared with claude-max.ts / github-copilot.ts when not overridden).\nlet authStorageInstance: AuthStorage | null = null;\n\n/** Get or create the shared AuthStorage instance. */\nexport function getAuthStorage(): AuthStorage {\n  if (!authStorageInstance) {\n    authStorageInstance = new AuthStorage();\n  }\n  return authStorageInstance;\n}\n\n/** Set a custom AuthStorage instance (useful for tests / TUI integration). */\nexport function setAuthStorage(storage: AuthStorage | undefined): void {\n  authStorageInstance = storage ?? null;\n}\n\n/**\n * Build a fetch wrapper that authenticates with xAI OAuth.\n * Injects the access token (auto-refreshed by AuthStorage) as a bearer token,\n * preserving non-auth headers from the caller.\n */\nexport function buildXAIOAuthFetch(opts: { authStorage?: CredentialStore } = {}): typeof fetch {\n  return (async (url: string | URL | Request, init?: Parameters<typeof fetch>[1]) => {\n    const storage = opts.authStorage ?? getAuthStorage();\n    storage.reload();\n\n    const cred = storage.get(XAI_PROVIDER_ID);\n    if (!cred || cred.type !== 'oauth') {\n      throw new ProviderAuthRequiredError('Not logged in to xAI.');\n    }\n\n    // getApiKey() refreshes the access token if it has expired.\n    const accessToken = await storage.getApiKey(XAI_PROVIDER_ID);\n    if (!accessToken) {\n      throw new ProviderAuthRequiredError('Failed to refresh the xAI token.');\n    }\n\n    // Preserve existing headers, strip auth-related ones. Explicit init\n    // headers override headers carried by an incoming Request.\n    const headers = new Headers(url instanceof Request ? url.headers : undefined);\n    if (init?.headers) {\n      new Headers(init.headers).forEach((value, key) => headers.set(key, value));\n    }\n    headers.delete('authorization');\n    headers.delete('x-api-key');\n\n    headers.set('Authorization', `Bearer ${accessToken}`);\n\n    try {\n      return await fetch(url, { ...init, headers });\n    } catch (error) {\n      if (error && typeof error === 'object') {\n        Object.assign(error as Record<string, unknown>, {\n          requestUrl: url instanceof URL ? url.toString() : typeof url === 'string' ? url : (url as Request).url,\n        });\n      }\n      throw error;\n    }\n  }) as typeof fetch;\n}\n\n/**\n * Creates an xAI model using OAuth authentication.\n * Uses OAuth tokens from AuthStorage (auto-refreshes when needed).\n */\nexport function xaiProvider(\n  modelId: string,\n  options?: { headers?: Record<string, string>; authStorage?: CredentialStore },\n): ReturnType<OpenAICompatibleProvider['chatModel']> {\n  const provider = createOpenAICompatible({\n    name: XAI_PROVIDER_ID,\n    baseURL: XAI_BASE_URL,\n    apiKey: 'oauth-placeholder', // real auth injected by the custom fetch\n    headers: options?.headers,\n    fetch: buildXAIOAuthFetch({ authStorage: options?.authStorage }),\n  });\n  return provider.chatModel(modelId);\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,MAAM,kBAAkB;AACxB,MAAM,eAAe;AAGrB,IAAI,sBAA0C;;AAG9C,SAAgB,iBAA8B;CAC5C,IAAI,CAAC,qBACH,sBAAsB,IAAI,YAAY;CAExC,OAAO;AACT;;AAGA,SAAgB,eAAe,SAAwC;CACrE,sBAAsB,WAAW;AACnC;;;;;;AAOA,SAAgB,mBAAmB,OAA0C,CAAC,GAAiB;CAC7F,QAAQ,OAAO,KAA6B,SAAuC;EACjF,MAAM,UAAU,KAAK,eAAe,eAAe;EACnD,QAAQ,OAAO;EAEf,MAAM,OAAO,QAAQ,IAAI,eAAe;EACxC,IAAI,CAAC,QAAQ,KAAK,SAAS,SACzB,MAAM,IAAI,0BAA0B,uBAAuB;EAI7D,MAAM,cAAc,MAAM,QAAQ,UAAU,eAAe;EAC3D,IAAI,CAAC,aACH,MAAM,IAAI,0BAA0B,kCAAkC;EAKxE,MAAM,UAAU,IAAI,QAAQ,eAAe,UAAU,IAAI,UAAU,KAAA,CAAS;EAC5E,IAAI,MAAM,SACR,IAAI,QAAQ,KAAK,OAAO,CAAC,CAAC,SAAS,OAAO,QAAQ,QAAQ,IAAI,KAAK,KAAK,CAAC;EAE3E,QAAQ,OAAO,eAAe;EAC9B,QAAQ,OAAO,WAAW;EAE1B,QAAQ,IAAI,iBAAiB,UAAU,aAAa;EAEpD,IAAI;GACF,OAAO,MAAM,MAAM,KAAK;IAAE,GAAG;IAAM;GAAQ,CAAC;EAC9C,SAAS,OAAO;GACd,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,OAAO,OAAkC,EAC9C,YAAY,eAAe,MAAM,IAAI,SAAS,IAAI,OAAO,QAAQ,WAAW,MAAO,IAAgB,IACrG,CAAC;GAEH,MAAM;EACR;CACF;AACF;;;;;AAMA,SAAgB,YACd,SACA,SACmD;CAQnD,OAPiB,uBAAuB;EACtC,MAAM;EACN,SAAS;EACT,QAAQ;EACR,SAAS,SAAS;EAClB,OAAO,mBAAmB,EAAE,aAAa,SAAS,YAAY,CAAC;CACjE,CACc,CAAC,CAAC,UAAU,OAAO;AACnC"}

package/dist/schedules/index.d.ts

@@ -0,0 +1,10 @@
+export { parseInterval, validateInterval, nextFireTime } from './interval.js';
+export type { ParsedInterval, IntervalError, IntervalCheck } from './interval.js';
+export { assembleSchedulePrompt, formatScriptOutput, SCRIPT_TIMEOUT_MS } from './prompt.js';
+export type { RunScript, ScriptResult, AssemblePromptOptions, AssembledPrompt } from './prompt.js';
+export { ThreadScheduler, shortScheduleId, describeScheduleSource, scheduleSignalAttributes, SCHEDULE_SIGNAL_SOURCE, LATE_FIRE_GRACE_MS, } from './scheduler.js';
+export type { ThreadSchedule, ThreadScheduleSpec, ThreadScheduleSource, ScheduleTrigger, ScheduleFile, ThreadSchedulerOptions, ScheduleRunResult, } from './scheduler.js';
+export { runScript, resolveScriptCommand, isExecutableFile } from './run-script.js';
+export { createScheduleTools, SCHEDULE_TOOL_IDS } from './tools.js';
+export type { ScheduleToolsOptions, ScheduleFileOptions } from './tools.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schedules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schedules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9E,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnG,OAAO,EACL,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/schedules/index.js

@@ -0,0 +1,6 @@
+import { nextFireTime, parseInterval, validateInterval } from "./interval.js";
+import { SCRIPT_TIMEOUT_MS, assembleSchedulePrompt, formatScriptOutput } from "./prompt.js";
+import { LATE_FIRE_GRACE_MS, SCHEDULE_SIGNAL_SOURCE, ThreadScheduler, describeScheduleSource, scheduleSignalAttributes, shortScheduleId } from "./scheduler.js";
+import { isExecutableFile, resolveScriptCommand, runScript } from "./run-script.js";
+import { SCHEDULE_TOOL_IDS, createScheduleTools } from "./tools.js";
+export { LATE_FIRE_GRACE_MS, SCHEDULE_SIGNAL_SOURCE, SCHEDULE_TOOL_IDS, SCRIPT_TIMEOUT_MS, ThreadScheduler, assembleSchedulePrompt, createScheduleTools, describeScheduleSource, formatScriptOutput, isExecutableFile, nextFireTime, parseInterval, resolveScriptCommand, runScript, scheduleSignalAttributes, shortScheduleId, validateInterval };

package/dist/schedules/interval.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Interval parsing and fire-time math for `/schedules`.
+ *
+ * Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock
+ * boundaries (5m fires at :00, :05, ...), so only intervals that divide the
+ * hour (minutes) or the day (hours) give a stable cadence; anything else is
+ * rejected with the nearest valid suggestion instead of silently drifting.
+ */
+export type ParsedInterval = {
+    ms: number;
+    label: string;
+};
+export type IntervalError = {
+    error: string;
+};
+/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */
+export declare function parseInterval(text: string): ParsedInterval | IntervalError;
+export type IntervalCheck = {
+    ok: true;
+} | {
+    error: string;
+    suggestion?: string;
+};
+/**
+ * Check that an interval fires on stable clock boundaries: whole minutes that
+ * divide the hour, whole hours that divide the day, or exactly one day.
+ */
+export declare function validateInterval({ ms }: {
+    ms: number;
+}): IntervalCheck;
+/**
+ * The first boundary strictly after `after`, on the local wall clock
+ * (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`
+ * must pass {@link validateInterval}.
+ *
+ * Around daylight-saving changes this behaves like cron:
+ * - Sub-hour cadences follow the minute hand, so they keep firing every N real
+ *   minutes through both the skipped and the repeated hour. Across a
+ *   half-hour change, the gap between fires never exceeds the interval.
+ * - Hourly and daily cadences fire once per wall-clock slot. A boundary that
+ *   falls in a skipped hour fires at the first minute after the jump (02:00 →
+ *   03:00), and a repeated hour does not fire a second time.
+ *
+ * Computing from `after` rather than from the previous fire means a late
+ * timer (sleep, busy event loop) skips missed boundaries instead of bursting
+ * to catch up.
+ */
+export declare function nextFireTime(intervalMs: number, after: number): number;
+//# sourceMappingURL=interval.d.ts.map

package/dist/schedules/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../../src/schedules/interval.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAyB9C,yFAAyF;AACzF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,aAAa,CAc1E;AAED,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAWlF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CA6CtE;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBtE"}

package/dist/schedules/interval.js

@@ -0,0 +1,215 @@
+//#region src/schedules/interval.ts
+/**
+* Interval parsing and fire-time math for `/schedules`.
+*
+* Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock
+* boundaries (5m fires at :00, :05, ...), so only intervals that divide the
+* hour (minutes) or the day (hours) give a stable cadence; anything else is
+* rejected with the nearest valid suggestion instead of silently drifting.
+*/
+const SECOND_MS = 1e3;
+const MINUTE_MS = 60 * SECOND_MS;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+const UNIT_MS = {
+	s: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	sec: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	secs: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	second: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	seconds: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	m: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	min: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	mins: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	minute: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	minutes: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	h: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hr: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hrs: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hour: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hours: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	d: {
+		ms: DAY_MS,
+		short: "d"
+	},
+	day: {
+		ms: DAY_MS,
+		short: "d"
+	},
+	days: {
+		ms: DAY_MS,
+		short: "d"
+	}
+};
+const INTERVAL_RE = /^(\d+)\s*([a-z]+)$/i;
+/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */
+function parseInterval(text) {
+	const match = INTERVAL_RE.exec(text.trim());
+	if (!match) return { error: `Invalid interval "${text}". Use a number followed by a unit, e.g. 5m, 2h, 1d.` };
+	const value = Number(match[1]);
+	const unit = UNIT_MS[match[2].toLowerCase()];
+	if (!unit) return { error: `Unknown interval unit "${match[2]}". Use s, m, h, or d.` };
+	if (value <= 0) return { error: "Interval must be greater than zero." };
+	return {
+		ms: value * unit.ms,
+		label: `${value}${unit.short}`
+	};
+}
+const MINUTE_DIVISORS = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	10,
+	12,
+	15,
+	20,
+	30,
+	60
+];
+const HOUR_DIVISORS = [
+	1,
+	2,
+	3,
+	4,
+	6,
+	8,
+	12,
+	24
+];
+function nearest(candidates, target) {
+	return candidates.reduce((best, candidate) => Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best);
+}
+/**
+* Check that an interval fires on stable clock boundaries: whole minutes that
+* divide the hour, whole hours that divide the day, or exactly one day.
+*/
+function validateInterval({ ms }) {
+	if (ms < MINUTE_MS) return {
+		error: "Schedules fire at most once per minute.",
+		suggestion: "1m"
+	};
+	if (ms % MINUTE_MS !== 0) {
+		const minutes = Math.round(ms / MINUTE_MS);
+		return {
+			error: "Interval must be a whole number of minutes.",
+			suggestion: `${Math.max(1, nearest(MINUTE_DIVISORS, minutes))}m`
+		};
+	}
+	const minutes = ms / MINUTE_MS;
+	if (minutes < 60) {
+		if (60 % minutes === 0) return { ok: true };
+		return {
+			error: `${minutes}m does not divide an hour evenly.`,
+			suggestion: `${nearest(MINUTE_DIVISORS, minutes)}m`
+		};
+	}
+	if (minutes % 60 !== 0) {
+		const hours = Math.round(minutes / 60);
+		return {
+			error: `${minutes}m is not a whole number of hours.`,
+			suggestion: hours < 24 ? `${nearest(HOUR_DIVISORS, hours)}h` : "1d"
+		};
+	}
+	const hours = minutes / 60;
+	if (hours < 24) {
+		if (24 % hours === 0) return { ok: true };
+		return {
+			error: `${hours}h does not divide a day evenly.`,
+			suggestion: `${nearest(HOUR_DIVISORS, hours)}h`
+		};
+	}
+	if (hours === 24) return { ok: true };
+	return {
+		error: "Intervals longer than one day are not supported.",
+		suggestion: "1d"
+	};
+}
+/** Hour-and-longer cadences: which local wall-clock slot a minute belongs to. */
+function hourSlotKey(date, stepHours) {
+	return ((date.getFullYear() * 12 + date.getMonth()) * 31 + date.getDate()) * 24 + Math.floor(date.getHours() / stepHours) * stepHours;
+}
+/**
+* The first boundary strictly after `after`, on the local wall clock
+* (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`
+* must pass {@link validateInterval}.
+*
+* Around daylight-saving changes this behaves like cron:
+* - Sub-hour cadences follow the minute hand, so they keep firing every N real
+*   minutes through both the skipped and the repeated hour. Across a
+*   half-hour change, the gap between fires never exceeds the interval.
+* - Hourly and daily cadences fire once per wall-clock slot. A boundary that
+*   falls in a skipped hour fires at the first minute after the jump (02:00 →
+*   03:00), and a repeated hour does not fire a second time.
+*
+* Computing from `after` rather than from the previous fire means a late
+* timer (sleep, busy event loop) skips missed boundaries instead of bursting
+* to catch up.
+*/
+function nextFireTime(intervalMs, after) {
+	const cursor = /* @__PURE__ */ new Date(Math.floor(after / MINUTE_MS) * MINUTE_MS);
+	const stepMinutes = intervalMs / MINUTE_MS;
+	if (stepMinutes < 60) {
+		const latest = cursor.getTime() + intervalMs;
+		do
+			cursor.setTime(cursor.getTime() + MINUTE_MS);
+		while (cursor.getMinutes() % stepMinutes !== 0 && cursor.getTime() < latest);
+		return cursor.getTime();
+	}
+	const stepHours = stepMinutes / 60;
+	const startSlot = hourSlotKey(new Date(after), stepHours);
+	do
+		cursor.setTime(cursor.getTime() + MINUTE_MS);
+	while (hourSlotKey(cursor, stepHours) <= startSlot);
+	return cursor.getTime();
+}
+//#endregion
+export { nextFireTime, parseInterval, validateInterval };
+
+//# sourceMappingURL=interval.js.map

package/dist/schedules/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","names":[],"sources":["../../src/schedules/interval.ts"],"sourcesContent":["/**\n * Interval parsing and fire-time math for `/schedules`.\n *\n * Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock\n * boundaries (5m fires at :00, :05, ...), so only intervals that divide the\n * hour (minutes) or the day (hours) give a stable cadence; anything else is\n * rejected with the nearest valid suggestion instead of silently drifting.\n */\n\nconst SECOND_MS = 1_000;\nconst MINUTE_MS = 60 * SECOND_MS;\nconst HOUR_MS = 60 * MINUTE_MS;\nconst DAY_MS = 24 * HOUR_MS;\n\nexport type ParsedInterval = { ms: number; label: string };\nexport type IntervalError = { error: string };\n\nconst UNIT_MS: Record<string, { ms: number; short: string }> = {\n  s: { ms: SECOND_MS, short: 's' },\n  sec: { ms: SECOND_MS, short: 's' },\n  secs: { ms: SECOND_MS, short: 's' },\n  second: { ms: SECOND_MS, short: 's' },\n  seconds: { ms: SECOND_MS, short: 's' },\n  m: { ms: MINUTE_MS, short: 'm' },\n  min: { ms: MINUTE_MS, short: 'm' },\n  mins: { ms: MINUTE_MS, short: 'm' },\n  minute: { ms: MINUTE_MS, short: 'm' },\n  minutes: { ms: MINUTE_MS, short: 'm' },\n  h: { ms: HOUR_MS, short: 'h' },\n  hr: { ms: HOUR_MS, short: 'h' },\n  hrs: { ms: HOUR_MS, short: 'h' },\n  hour: { ms: HOUR_MS, short: 'h' },\n  hours: { ms: HOUR_MS, short: 'h' },\n  d: { ms: DAY_MS, short: 'd' },\n  day: { ms: DAY_MS, short: 'd' },\n  days: { ms: DAY_MS, short: 'd' },\n};\n\nconst INTERVAL_RE = /^(\\d+)\\s*([a-z]+)$/i;\n\n/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */\nexport function parseInterval(text: string): ParsedInterval | IntervalError {\n  const match = INTERVAL_RE.exec(text.trim());\n  if (!match) {\n    return { error: `Invalid interval \"${text}\". Use a number followed by a unit, e.g. 5m, 2h, 1d.` };\n  }\n  const value = Number(match[1]);\n  const unit = UNIT_MS[match[2]!.toLowerCase()];\n  if (!unit) {\n    return { error: `Unknown interval unit \"${match[2]}\". Use s, m, h, or d.` };\n  }\n  if (value <= 0) {\n    return { error: 'Interval must be greater than zero.' };\n  }\n  return { ms: value * unit.ms, label: `${value}${unit.short}` };\n}\n\nexport type IntervalCheck = { ok: true } | { error: string; suggestion?: string };\n\nconst MINUTE_DIVISORS = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60];\nconst HOUR_DIVISORS = [1, 2, 3, 4, 6, 8, 12, 24];\n\nfunction nearest(candidates: number[], target: number): number {\n  return candidates.reduce((best, candidate) =>\n    Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best,\n  );\n}\n\n/**\n * Check that an interval fires on stable clock boundaries: whole minutes that\n * divide the hour, whole hours that divide the day, or exactly one day.\n */\nexport function validateInterval({ ms }: { ms: number }): IntervalCheck {\n  if (ms < MINUTE_MS) {\n    return { error: 'Schedules fire at most once per minute.', suggestion: '1m' };\n  }\n  if (ms % MINUTE_MS !== 0) {\n    const minutes = Math.round(ms / MINUTE_MS);\n    return {\n      error: 'Interval must be a whole number of minutes.',\n      suggestion: `${Math.max(1, nearest(MINUTE_DIVISORS, minutes))}m`,\n    };\n  }\n  const minutes = ms / MINUTE_MS;\n  if (minutes < 60) {\n    if (60 % minutes === 0) {\n      return { ok: true };\n    }\n    return {\n      error: `${minutes}m does not divide an hour evenly.`,\n      suggestion: `${nearest(MINUTE_DIVISORS, minutes)}m`,\n    };\n  }\n  if (minutes % 60 !== 0) {\n    const hours = Math.round(minutes / 60);\n    return {\n      error: `${minutes}m is not a whole number of hours.`,\n      suggestion: hours < 24 ? `${nearest(HOUR_DIVISORS, hours)}h` : '1d',\n    };\n  }\n  const hours = minutes / 60;\n  if (hours < 24) {\n    if (24 % hours === 0) {\n      return { ok: true };\n    }\n    return {\n      error: `${hours}h does not divide a day evenly.`,\n      suggestion: `${nearest(HOUR_DIVISORS, hours)}h`,\n    };\n  }\n  if (hours === 24) {\n    return { ok: true };\n  }\n  return {\n    error: 'Intervals longer than one day are not supported.',\n    suggestion: '1d',\n  };\n}\n\n/** Hour-and-longer cadences: which local wall-clock slot a minute belongs to. */\nfunction hourSlotKey(date: Date, stepHours: number): number {\n  return (\n    ((date.getFullYear() * 12 + date.getMonth()) * 31 + date.getDate()) * 24 +\n    Math.floor(date.getHours() / stepHours) * stepHours\n  );\n}\n\n/**\n * The first boundary strictly after `after`, on the local wall clock\n * (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`\n * must pass {@link validateInterval}.\n *\n * Around daylight-saving changes this behaves like cron:\n * - Sub-hour cadences follow the minute hand, so they keep firing every N real\n *   minutes through both the skipped and the repeated hour. Across a\n *   half-hour change, the gap between fires never exceeds the interval.\n * - Hourly and daily cadences fire once per wall-clock slot. A boundary that\n *   falls in a skipped hour fires at the first minute after the jump (02:00 →\n *   03:00), and a repeated hour does not fire a second time.\n *\n * Computing from `after` rather than from the previous fire means a late\n * timer (sleep, busy event loop) skips missed boundaries instead of bursting\n * to catch up.\n */\nexport function nextFireTime(intervalMs: number, after: number): number {\n  // Truncate in UTC: local setters resolve a repeated hour to its first occurrence.\n  const cursor = new Date(Math.floor(after / MINUTE_MS) * MINUTE_MS);\n  const stepMinutes = intervalMs / MINUTE_MS;\n  // Walk minute by minute: at most an hour for sub-hour cadences, ~a day otherwise.\n  if (stepMinutes < 60) {\n    // Never wait longer than one interval: a half-hour clock change (Lord Howe\n    // Island) can otherwise shift the minute hand past the next boundary.\n    const latest = cursor.getTime() + intervalMs;\n    do cursor.setTime(cursor.getTime() + MINUTE_MS);\n    while (cursor.getMinutes() % stepMinutes !== 0 && cursor.getTime() < latest);\n    return cursor.getTime();\n  }\n  const stepHours = stepMinutes / 60;\n  const startSlot = hourSlotKey(new Date(after), stepHours);\n  do cursor.setTime(cursor.getTime() + MINUTE_MS);\n  while (hourSlotKey(cursor, stepHours) <= startSlot);\n  return cursor.getTime();\n}\n"],"mappings":"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"}