Settings API

// Check provider readiness before creating tasks
const res: Response = await fetch('http://localhost:3000/api/settings/providers');
const { providers, routingPreference, configuredProviderCount }: {
providers: Record<string, any>;
routingPreference: string;
configuredProviderCount: number;
} = await res.json();

console.log(`${configuredProviderCount} provider(s) configured`);
console.log(`Anthropic: ${providers.anthropic.configured ? 'ready' : 'not configured'}`);
console.log(`OpenAI: ${providers.openai.configured ? 'ready' : 'not configured'}`);
console.log(`Routing: ${routingPreference}`);

// Warn about dual billing
if (providers.anthropic.dualBilling) {
console.warn('Both OAuth and API key active — may cause double billing');
}

// Read current Anthropic auth settings
const res: Response = await fetch('http://localhost:3000/api/settings');
const auth: { method: string; hasKey: boolean; apiKeySource?: string } = await res.json();
console.log(`Auth method: ${auth.method}, key present: ${auth.hasKey}`);

// Set or rotate the Anthropic API key
await fetch('http://localhost:3000/api/settings', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ apiKey: 'sk-ant-api03-...' }),
});

// Read current OpenAI auth settings
const res: Response = await fetch('http://localhost:3000/api/settings/openai');
const openai: { hasKey: boolean; apiKeySource?: string } = await res.json();
console.log(`OpenAI key present: ${openai.hasKey}`);

// Configure OpenAI for Codex runtime access
await fetch('http://localhost:3000/api/settings/openai', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ apiKey: 'sk-proj-...' }),
});

// Check budget before running a large task
const res: Response = await fetch('http://localhost:3000/api/settings/budgets');
const budget: {
dailyLimit: number; monthlyLimit: number;
dailySpend: number; monthlySpend: number;
alertThreshold: number;
} = await res.json();

console.log(`Daily: $${budget.dailySpend.toFixed(2)} / $${budget.dailyLimit.toFixed(2)}`);
console.log(`Monthly: $${budget.monthlySpend.toFixed(2)} / $${budget.monthlyLimit.toFixed(2)}`);

if (budget.dailySpend / budget.dailyLimit > 0.8) {
console.warn('Approaching daily budget limit');
}

// Set budget guardrails
await fetch('http://localhost:3000/api/settings/budgets', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  dailyLimit: 10.00,
  monthlyLimit: 200.00,
  alertThreshold: 0.8, // warn at 80% usage
}),
});

// Read current routing preference
const res: Response = await fetch('http://localhost:3000/api/settings/routing');
const { preference }: { preference: string } = await res.json();
console.log(`Current routing: ${preference}`);

// Switch to cost-optimized routing
await fetch('http://localhost:3000/api/settings/routing', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ preference: 'cost' }),
});

// Check model pricing for cost estimation
const res: Response = await fetch('http://localhost:3000/api/settings/pricing');
const pricing: { models: Array<{ modelId: string; inputPer1M: number; outputPer1M: number }> } = await res.json();

pricing.models.forEach((m) => {
console.log(`${m.modelId}: $${m.inputPer1M}/M input, $${m.outputPer1M}/M output`);
});

// Force a pricing refresh after provider announcements
const res: Response = await fetch('http://localhost:3000/api/settings/pricing', { method: 'POST' });
const pricing: { models: Array<{ modelId: string }> } = await res.json();
console.log(`Pricing updated: ${pricing.models.length} models`);

// Read the default chat model
const res: Response = await fetch('http://localhost:3000/api/settings/chat');
const { defaultModel }: { defaultModel: string } = await res.json();
console.log(`Chat model: ${defaultModel}`);

// Switch the default chat model
await fetch('http://localhost:3000/api/settings/chat', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ defaultModel: 'claude-sonnet-4-6-20250514' }),
});

// Read SDK timeout and max-turns settings
const res: Response = await fetch('http://localhost:3000/api/settings/runtime');
const runtime: { sdkTimeoutSeconds: string; maxTurns: string } = await res.json();
console.log(`Timeout: ${runtime.sdkTimeoutSeconds}s, Max turns: ${runtime.maxTurns}`);

// Increase limits for complex agent tasks
await fetch('http://localhost:3000/api/settings/runtime', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ sdkTimeoutSeconds: '120', maxTurns: '25' }),
});

// Read Ollama connection settings
const res: Response = await fetch('http://localhost:3000/api/settings/ollama');
const ollama: { baseUrl: string; defaultModel: string } = await res.json();
console.log(`Ollama: ${ollama.baseUrl}, model: ${ollama.defaultModel || '(not set)'}`);

// Point to a local Ollama instance
await fetch('http://localhost:3000/api/settings/ollama', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ baseUrl: 'http://localhost:11434', defaultModel: 'llama3.1' }),
});

// Read the learning context character limit
const res: Response = await fetch('http://localhost:3000/api/settings/learning');
const { contextCharLimit }: { contextCharLimit: string } = await res.json();
console.log(`Learning context limit: ${Number(contextCharLimit).toLocaleString()} chars`);

// Double the learning context window
await fetch('http://localhost:3000/api/settings/learning', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ contextCharLimit: '16000' }),
});

// Read browser tool enablement
const res: Response = await fetch('http://localhost:3000/api/settings/browser-tools');
const tools: { chromeDevtoolsEnabled: boolean; playwrightEnabled: boolean } = await res.json();
console.log(`Chrome DevTools: ${tools.chromeDevtoolsEnabled ? 'on' : 'off'}`);
console.log(`Playwright: ${tools.playwrightEnabled ? 'on' : 'off'}`);

// Enable Chrome DevTools MCP for browser-based tasks
await fetch('http://localhost:3000/api/settings/browser-tools', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  chromeDevtoolsEnabled: true,
  playwrightEnabled: false,
}),
});

// Read Exa web search enablement
const res: Response = await fetch('http://localhost:3000/api/settings/web-search');
const { exaSearchEnabled }: { exaSearchEnabled: boolean } = await res.json();
console.log(`Web search: ${exaSearchEnabled ? 'enabled' : 'disabled'}`);

// Enable web search for research-oriented agents
await fetch('http://localhost:3000/api/settings/web-search', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ exaSearchEnabled: true }),
});

// Get the OS username as default author
const res: Response = await fetch('http://localhost:3000/api/settings/author-default');
const { author }: { author: string } = await res.json();
console.log(`Default author: ${author}`);

// Test runtime connectivity
const res: Response = await fetch('http://localhost:3000/api/settings/test', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ runtime: 'claude-code' }),
});
const result: { connected: boolean; runtime: string; capabilities: Record<string, any>; error?: string } = await res.json();

if (result.connected) {
console.log(`${result.runtime} is ready`);
console.log('Capabilities:', result.capabilities);
} else {
console.error(`Connection failed: ${result.error}`);
}

// Load pinned entities to pre-populate the mention popover
const res: Response = await fetch('http://localhost:3000/api/settings/chat/pins');
const { pins }: { pins: Array<{ id: string; type: string; label: string; pinnedAt: string }> } = await res.json();

console.log(`${pins.length} pinned entities`);
pins.forEach((p) => console.log(`  [${p.type}] ${p.label}`));

// Pin a new task: read → append → write
const existing = await fetch('http://localhost:3000/api/settings/chat/pins')
.then((r: Response) => r.json());

const updated = [
...existing.pins,
{
  id: 'task-c3d4-e5f6',
  type: 'task',
  label: 'Deploy v2.1 release',
  status: 'queued',
  pinnedAt: new Date().toISOString(),
},
];

await fetch('http://localhost:3000/api/settings/chat/pins', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ pins: updated }),
});

// Load saved searches for the ⌘K palette
const res: Response = await fetch('http://localhost:3000/api/settings/chat/saved-searches');
const { searches }: { searches: Array<{ id: string; surface: string; label: string; filterInput: string }> } = await res.json();

console.log(`${searches.length} saved searches`);
searches.forEach((s) => console.log(`  [${s.surface}] ${s.label}: "${s.filterInput}"`));

import { v4 as uuidv4 } from 'uuid';

// Save a new search: read → append → write
const existing = await fetch('http://localhost:3000/api/settings/chat/saved-searches')
.then((r: Response) => r.json());

const updated = [
...existing.searches,
{
  id: uuidv4(),
  surface: 'task',
  label: 'P0 tasks this week',
  filterInput: 'priority:0 status:queued',
  createdAt: new Date().toISOString(),
},
];

await fetch('http://localhost:3000/api/settings/chat/saved-searches', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ searches: updated }),
});

// Poll the login state while the browser flow is in progress
const res: Response = await fetch('http://localhost:3000/api/settings/openai/login');
const state: { status: string; loginUrl?: string; error?: string } = await res.json();

if (state.status === 'pending' && state.loginUrl) {
console.log(`Open in browser: ${state.loginUrl}`);
} else if (state.status === 'success') {
console.log('OpenAI OAuth login complete');
} else if (state.status === 'error') {
console.error(`Login failed: ${state.error}`);
}

// Kick off the OAuth flow — open the returned URL in a browser
const res: Response = await fetch('http://localhost:3000/api/settings/openai/login', {
method: 'POST',
});
const state: { status: string; loginUrl?: string } = await res.json();

if (state.loginUrl) {
// Open the URL in the user's default browser
console.log(`Navigate to: ${state.loginUrl}`);
// Then poll GET /api/settings/openai/login until status === "success"
}

// Cancel the pending OAuth flow (e.g. user closed the dialog)
const res: Response = await fetch('http://localhost:3000/api/settings/openai/login', {
method: 'DELETE',
});
const state: { status: string } = await res.json();
console.log(`Login state: ${state.status}`); // "idle"

// Sign out of the Codex App Server session
await fetch('http://localhost:3000/api/settings/openai/logout', { method: 'POST' });
console.log('Codex session cleared');

// Check whether auto-promote is enabled
const res: Response = await fetch('http://localhost:3000/api/settings/environment');
const { autoPromoteSkills }: { autoPromoteSkills: boolean } = await res.json();
console.log(`Auto-promote skills: ${autoPromoteSkills ? 'on' : 'off'}`);

// Enable auto-promote so agent-generated skills are added to the library automatically
await fetch('http://localhost:3000/api/settings/environment', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ autoPromoteSkills: true }),
});