ToCode

sql\CASE WHEN ${t.type} = 'tool-getLocation' THEN ${t.tool_toolCallId} IS NOT NULL AND ${t.tool_state} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "data_weather_fields_required",
      sql\CASE WHEN ${t.type} = 'data-weather' THEN ${t.data_weather_location} IS NOT NULL AND ${t.data_weather_weather} IS NOT NULL AND ${t.data_weather_temperature} IS NOT NULL ELSE TRUE END\,
    ),
  ],
);

export type MyDBUIMessagePart = typeof parts.$inferInsert;
export type MyDBUIMessagePartSelect = typeof parts.$inferSelect;

"messages",
  {
    id: varchar()
      .primaryKey()
      .$defaultFn(() => generateId()),
    chatId: varchar()
      .references(() => chats.id, { onDelete: "cascade" })
      .notNull(),
    createdAt: timestamp().defaultNow().notNull(),
    role: varchar().$type<MyUIMessage["role"]>().notNull(),
  },
  (table) => [
    index("messages_chat_id_idx").on(table.chatId),
    index("messages_chat_id_created_at_idx").on(table.chatId, table.createdAt),
  ],
);

export const parts = pgTable(
  "parts",
  {
    id: varchar()
      .primaryKey()
      .$defaultFn(() => generateId()),
    messageId: varchar()
      .references(() => messages.id, { onDelete: "cascade" })
      .notNull(),
    type: varchar().$type<MyUIMessage["parts"][0]["type"]>().notNull(),
    createdAt: timestamp().defaultNow().notNull(),
    order: integer().notNull().default(0),

    // Text fields
    text_text: text(),

    // Reasoning fields
    reasoning_text: text(),

    // File fields
    file_mediaType: varchar(),
    file_filename: varchar(), // optional
    file_url: varchar(),

    // Source url fields
    source_url_sourceId: varchar(),
    source_url_url: varchar(),
    source_url_title: varchar(), // optional

    // Source document fields
    source_document_sourceId: varchar(),
    source_document_mediaType: varchar(),
    source_document_title: varchar(),
    source_document_filename: varchar(), // optional

    // shared tool call columns
    tool_toolCallId: varchar(),
    tool_state: varchar().$type<ToolUIPart["state"]>(),
    tool_errorText: varchar().$type<ToolUIPart["state"]>(),

    // tools inputs and outputss are stored in separate cols
    tool_getWeatherInformation_input:
      jsonb().$type<getWeatherInformationInput>(),
    tool_getWeatherInformation_output:
      jsonb().$type<getWeatherInformationOutput>(),

    tool_getLocation_input: jsonb().$type<getLocationInput>(),
    tool_getLocation_output: jsonb().$type<getLocationOutput>(),

    // Data parts
    data_weather_id: varchar().$defaultFn(() => generateId()),
    data_weather_location: varchar().$type<MyDataPart["weather"]["location"]>(),
    data_weather_weather: varchar().$type<MyDataPart["weather"]["weather"]>(),
    data_weather_temperature:
      real().$type<MyDataPart["weather"]["temperature"]>(),

    providerMetadata: jsonb().$type<MyProviderMetadata>(),
  },
  (t) => [
    // Indexes for performance optimisation
    index("parts_message_id_idx").on(t.messageId),
    index("parts_message_id_order_idx").on(t.messageId, t.order),

    // Check constraints
    check(
      "text_text_required_if_type_is_text",
      // This SQL expression enforces: if type = 'text' then text_text IS NOT NULL
      sql\CASE WHEN ${t.type} = 'text' THEN ${t.text_text} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "reasoning_text_required_if_type_is_reasoning",
      sql\CASE WHEN ${t.type} = 'reasoning' THEN ${t.reasoning_text} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "file_fields_required_if_type_is_file",
      sql\CASE WHEN ${t.type} = 'file' THEN ${t.file_mediaType} IS NOT NULL AND ${t.file_url} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "source_url_fields_required_if_type_is_source_url",
      sql\CASE WHEN ${t.type} = 'source_url' THEN ${t.source_url_sourceId} IS NOT NULL AND ${t.source_url_url} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "source_document_fields_required_if_type_is_source_document",
      sql\CASE WHEN ${t.type} = 'source_document' THEN ${t.source_document_sourceId} IS NOT NULL AND ${t.source_document_mediaType} IS NOT NULL AND ${t.source_document_title} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "tool_getWeatherInformation_fields_required",
      sql\CASE WHEN ${t.type} = 'tool-getWeatherInformation' THEN ${t.tool_toolCallId} IS NOT NULL AND ${t.tool_state} IS NOT NULL ELSE TRUE END\,
    ),
    check(
      "tool_getLocation_fields_required",

import asyncio

from agents import Agent, Runner, SQLiteSession

async def main():
    agent = Agent(name="Assistant", instructions="Reply very concisely.")

    # Create session instance
    session = SQLiteSession("conversation_123", "chats.db")

    # First turn
    result = await Runner.run(agent, "What city is the Golden Gate Bridge in?", session=session)
    print(result.final_output)
    # San Francisco

    # Second turn - agent automatically remembers previous context
    result = await Runner.run(agent, "What state is it in?", session=session)
    print(result.final_output)
    # California

if __name__ == '__main__':
    asyncio.run(main())

sqlite> .tables
agent_messages  agent_sessions
sqlite> select * from agent_messages ;
1|conversation_123|{"content": "What city is the Golden Gate Bridge in?", "role": "user"}|2025-07-30 13:35:36
2|conversation_123|{"id": "msg_688a1fa7fbe0819b9f4096e23741045f0d855ca99eba94a7", "content": [{"annotations": [], "text": "San Francisco.", "type": "output_text", "logprobs": []}], "role": "assistant", "status": "completed", "type": "message"}|2025-07-30 13:35:36
3|conversation_123|{"content": "What state is it in?", "role": "user"}|2025-07-30 13:35:37
4|conversation_123|{"id": "msg_688a1fa8fde0819b958bac6b45c84f900d855ca99eba94a7", "content": [{"annotations": [], "text": "California.", "type": "output_text", "logprobs": []}], "role": "assistant", "status": "completed", "type": "message"}|2025-07-30 13:35:37
sqlite> select * from agent_sessions ;
conversation_123|2025-07-30 13:35:36|2025-07-30 13:35:37

rails g model Chat model_id:string user:references
rails g model Message chat:references role:string content:text model_id:string input_tokens:integer output_tokens:integer tool_call:references
rails g model ToolCall message:references tool_call_id:string:index name:string arguments:jsonb

import {
  check,
  index,
  integer,
  jsonb,
  pgTable,
  real,
  text,
  timestamp,
  varchar,
} from "drizzle-orm/pg-core";
import { MyDataPart, MyUIMessage, MyProviderMetadata } from "../message-type";
import { generateId, ToolUIPart } from "ai";
import { sql } from "drizzle-orm";
import {
  getLocationInput,
  getLocationOutput,
  getWeatherInformationInput,
  getWeatherInformationOutput,
} from "@/ai/tools";

export const chats = pgTable("chats", {
  id: varchar()
    .primaryKey()
    .$defaultFn(() => generateId()),
});

export const messages = pgTable(

3.3.5 :027 > "hello world".split
 => ["hello", "world"]

3.3.5 :029 > "Don't. go. there".split
 => ["Don't.", "go.", "there"]

3.3.5 :032 > "Don't. go. there".scan(/\p{L}+(?:'\p{L}+)*/u)
 => ["Don't", "go", "there"]

3.3.5 :036 > text = "Don't means Don't - Don't press the button"
 => "Don't means Don't - Don't press the button"
3.3.5 :037 > third_word = text.scan(/\p{L}+(?:'\p{L}+)*/u)[2]
 => "Don't"
3.3.5 :038 > index_of_third_word = text.index(third_word)
 => 0

3.3.5 :039 > class String
3.3.5 :040 >     def tokenize
3.3.5 :041 >     regex = Regexp.new(/\p{L}+(?:'\p{L}+)*/u)
3.3.5 :042 >
3.3.5 :043 >     Enumerator.new do |y|
3.3.5 :044 >       pos = 0
3.3.5 :045 >       while m = regex.match(self, pos)
3.3.5 :046 >         y << m
3.3.5 :047 >         pos = m.end(0)
3.3.5 :048 >       end
3.3.5 :049 >     end
3.3.5 :050 >   end
3.3.5 :051 > end

3.3.5 :056 > text.tokenize.to_a
 =>
[#<MatchData "Don't">,
 #<MatchData "means">,
 #<MatchData "Don't">,
 #<MatchData "Don't">,
 #<MatchData "press">,
 #<MatchData "the">,
 #<MatchData "button">]

3.3.5 :057 > text.tokenize.map { |m| [m.to_s, m.begin(0)] }
 => [["Don't", 0], ["means", 6], ["Don't", 12], ["Don't", 20], ["press", 26], ["the", 32], ["button", 36]]

3.3.5 :060 > text.tokenize.drop(2).first.begin(0)
 => 12

test 'Person name with only spaces is trimmed to empty' do
  b = Person.new(name: '   ')
  b.save
  assert_equal('', b.name)
end

test 'Person name with only spaces is trimmed to empty' do
  b = Person.new(name: '   ')
  b.valid? # trigger validation to trim b.name
  assert_equal('', b.name)
end